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

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gdb/] [gdb-6.8/] [sim/] [cris/] [cpuv32.h] - Blame information for rev 26

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 26 jlechner
/* CPU family header for crisv32f.
2
 
3
THIS FILE IS MACHINE GENERATED WITH CGEN.
4
 
5
Copyright 1996-2007 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 CPU_CRISV32F_H
26
#define CPU_CRISV32F_H
27
 
28
/* Maximum number of instructions that are fetched at a time.
29
   This is for LIW type instructions sets (e.g. m32r).  */
30
#define MAX_LIW_INSNS 1
31
 
32
/* Maximum number of instructions that can be executed in parallel.  */
33
#define MAX_PARALLEL_INSNS 1
34
 
35
/* CPU state information.  */
36
typedef struct {
37
  /* Hardware elements.  */
38
  struct {
39
  /* program counter */
40
  USI h_pc;
41
#define GET_H_PC() CPU (h_pc)
42
#define SET_H_PC(x) \
43
do { \
44
CPU (h_pc) = ANDSI ((x), (~ (1)));\
45
;} while (0)
46
  /* General purpose registers */
47
  SI h_gr_acr[16];
48
#define GET_H_GR_ACR(a1) CPU (h_gr_acr)[a1]
49
#define SET_H_GR_ACR(a1, x) (CPU (h_gr_acr)[a1] = (x))
50
  /* Special registers for v32 */
51
  SI h_sr_v32[16];
52
#define GET_H_SR_V32(index) (ORIF (ORIF (((index) == (((UINT) 0))), ((index) == (((UINT) 4)))), ((index) == (((UINT) 8))))) ? (0) : (((index) == (((UINT) 1)))) ? (32) : (((index) == (((UINT) 13)))) ? (ORSI (ANDSI (CPU (h_sr_v32[((UINT) 13)]), 1073740800), ORSI (ZEXTBISI (CPU (h_cbit)), ORSI (SLLSI (ZEXTBISI (CPU (h_vbit)), 1), ORSI (SLLSI (ZEXTBISI (CPU (h_zbit)), 2), ORSI (SLLSI (ZEXTBISI (CPU (h_nbit)), 3), ORSI (SLLSI (ZEXTBISI (CPU (h_xbit)), 4), ORSI (SLLSI (ZEXTBISI (GET_H_IBIT ()), 5), ORSI (SLLSI (ZEXTBISI (GET_H_UBIT ()), 6), ORSI (SLLSI (ZEXTBISI (CPU (h_pbit)), 7), ORSI (SLLSI (ZEXTBISI (CPU (h_rbit)), 8), ORSI (SLLSI (ZEXTBISI (CPU (h_sbit)), 9), ORSI (SLLSI (ZEXTBISI (CPU (h_mbit)), 30), ORSI (SLLSI (ZEXTBISI (CPU (h_qbit)), 31), 0)))))))))))))) : (((index) == (((UINT) 14)))) ? (((GET_H_UBIT ()) ? (CPU (h_gr_acr[((UINT) 14)])) : (CPU (h_sr_v32[((UINT) 14)])))) : (CPU (h_sr_v32[index]))
53
#define SET_H_SR_V32(index, x) \
54
do { \
55
if (ORIF (ORIF ((((index)) == (((UINT) 0))), (((index)) == (((UINT) 4)))), ORIF ((((index)) == (((UINT) 8))), (((index)) == (((UINT) 1)))))) {\
56
((void) 0); /*nop*/\
57
}\
58
 else if ((((index)) == (((UINT) 13)))) {\
59
{\
60
CPU (h_cbit) = ((NESI (ANDSI ((x), ((1) << (0))), 0)) ? (1) : (0));\
61
CPU (h_vbit) = ((NESI (ANDSI ((x), ((1) << (1))), 0)) ? (1) : (0));\
62
CPU (h_zbit) = ((NESI (ANDSI ((x), ((1) << (2))), 0)) ? (1) : (0));\
63
CPU (h_nbit) = ((NESI (ANDSI ((x), ((1) << (3))), 0)) ? (1) : (0));\
64
CPU (h_xbit) = ((NESI (ANDSI ((x), ((1) << (4))), 0)) ? (1) : (0));\
65
SET_H_IBIT (((NESI (ANDSI ((x), ((1) << (5))), 0)) ? (1) : (0)));\
66
SET_H_SBIT (((NESI (ANDSI ((x), ((1) << (9))), 0)) ? (1) : (0)));\
67
SET_H_MBIT (((NESI (ANDSI ((x), ((1) << (30))), 0)) ? (1) : (0)));\
68
CPU (h_pbit) = ((NESI (ANDSI ((x), ((1) << (7))), 0)) ? (1) : (0));\
69
CPU (h_rbit) = ((NESI (ANDSI ((x), ((1) << (8))), 0)) ? (1) : (0));\
70
SET_H_QBIT (((NESI (ANDSI ((x), ((1) << (31))), 0)) ? (1) : (0)));\
71
SET_H_UBIT (((NESI (ANDSI ((x), ((1) << (6))), 0)) ? (1) : (0)));\
72
CPU (h_sr_v32[(index)]) = (x);\
73
}\
74
}\
75
 else if ((((index)) == (((UINT) 14)))) {\
76
{\
77
if (GET_H_UBIT ()) {\
78
CPU (h_gr_acr[((UINT) 14)]) = (x);\
79
}\
80
CPU (h_sr_v32[((UINT) 14)]) = (x);\
81
}\
82
}\
83
 else if ((((index)) == (((UINT) 3)))) {\
84
if (NOTBI (GET_H_UBIT ())) {\
85
CPU (h_sr_v32[((UINT) 3)]) = (x);\
86
}\
87
}\
88
 else if ((((index)) == (((UINT) 9)))) {\
89
if (NOTBI (GET_H_UBIT ())) {\
90
CPU (h_sr_v32[((UINT) 9)]) = (x);\
91
}\
92
}\
93
 else if ((((index)) == (((UINT) 2)))) {\
94
if (NOTBI (GET_H_UBIT ())) {\
95
{\
96
crisv32f_write_pid_handler (current_cpu, (x));\
97
CPU (h_sr_v32[((UINT) 2)]) = (x);\
98
}\
99
}\
100
}\
101
 else if ((((index)) == (((UINT) 15)))) {\
102
if (NOTBI (GET_H_UBIT ())) {\
103
CPU (h_sr_v32[((UINT) 15)]) = (x);\
104
}\
105
}\
106
 else {\
107
CPU (h_sr_v32[(index)]) = (x);\
108
}\
109
;} while (0)
110
  /* carry bit */
111
  BI h_cbit;
112
#define GET_H_CBIT() CPU (h_cbit)
113
#define SET_H_CBIT(x) (CPU (h_cbit) = (x))
114
  /* overflow bit */
115
  BI h_vbit;
116
#define GET_H_VBIT() CPU (h_vbit)
117
#define SET_H_VBIT(x) (CPU (h_vbit) = (x))
118
  /* zero bit */
119
  BI h_zbit;
120
#define GET_H_ZBIT() CPU (h_zbit)
121
#define SET_H_ZBIT(x) (CPU (h_zbit) = (x))
122
  /* sign bit */
123
  BI h_nbit;
124
#define GET_H_NBIT() CPU (h_nbit)
125
#define SET_H_NBIT(x) (CPU (h_nbit) = (x))
126
  /* extended-arithmetic bit */
127
  BI h_xbit;
128
#define GET_H_XBIT() CPU (h_xbit)
129
#define SET_H_XBIT(x) (CPU (h_xbit) = (x))
130
  /* sequence-broken bit */
131
  BI h_pbit;
132
#define GET_H_PBIT() CPU (h_pbit)
133
#define SET_H_PBIT(x) (CPU (h_pbit) = (x))
134
  /* carry bit for MCP+restore-p bit */
135
  BI h_rbit;
136
#define GET_H_RBIT() CPU (h_rbit)
137
#define SET_H_RBIT(x) (CPU (h_rbit) = (x))
138
  /* guru mode bit */
139
  BI h_gbit;
140
#define GET_H_GBIT() CPU (h_gbit)
141
#define SET_H_GBIT(x) (CPU (h_gbit) = (x))
142
  /* Kernel stack pointer during user mode */
143
  SI h_kernel_sp;
144
#define GET_H_KERNEL_SP() CPU (h_kernel_sp)
145
#define SET_H_KERNEL_SP(x) (CPU (h_kernel_sp) = (x))
146
  /* User mode bit */
147
  BI h_ubit_v32;
148
#define GET_H_UBIT_V32() CPU (h_ubit_v32)
149
#define SET_H_UBIT_V32(x) \
150
do { \
151
{\
152
if (ANDIF ((x), NOTBI (CPU (h_ubit_v32)))) {\
153
{\
154
CPU (h_kernel_sp) = CPU (h_gr_acr[((UINT) 14)]);\
155
CPU (h_gr_acr[((UINT) 14)]) = CPU (h_sr_v32[((UINT) 14)]);\
156
CPU (h_ubit_v32) = (x);\
157
crisv32f_usermode_enabled (current_cpu);\
158
}\
159
}\
160
}\
161
;} while (0)
162
  /* Interrupt-enable bit */
163
  BI h_ibit_v32;
164
#define GET_H_IBIT_V32() CPU (h_ibit_v32)
165
#define SET_H_IBIT_V32(x) \
166
do { \
167
{\
168
if (NOTBI (GET_H_UBIT ())) {\
169
{\
170
  BI tmp_enabled;\
171
  tmp_enabled = ANDIF ((x), NOTBI (CPU (h_ibit_v32)));\
172
CPU (h_ibit_v32) = (x);\
173
if (tmp_enabled) {\
174
crisv32f_interrupts_enabled (current_cpu);\
175
}\
176
}\
177
}\
178
}\
179
;} while (0)
180
  /* NMI enable bit */
181
  BI h_mbit;
182
#define GET_H_MBIT() CPU (h_mbit)
183
#define SET_H_MBIT(x) \
184
do { \
185
{\
186
if (ANDIF ((x), ANDIF (NOTBI (CPU (h_mbit)), NOTBI (GET_H_UBIT ())))) {\
187
{\
188
CPU (h_mbit) = 1;\
189
crisv32f_nmi_enabled (current_cpu);\
190
}\
191
}\
192
}\
193
;} while (0)
194
  /* Pending single-step bit */
195
  BI h_qbit;
196
#define GET_H_QBIT() CPU (h_qbit)
197
#define SET_H_QBIT(x) \
198
do { \
199
{\
200
if (NOTBI (GET_H_UBIT ())) {\
201
CPU (h_qbit) = (x);\
202
}\
203
}\
204
;} while (0)
205
  /* Cause single step exception on ... [see CRISv32 ref] bit */
206
  BI h_sbit;
207
#define GET_H_SBIT() CPU (h_sbit)
208
#define SET_H_SBIT(x) \
209
do { \
210
{\
211
if (NOTBI (GET_H_UBIT ())) {\
212
{\
213
  BI tmp_enabled;\
214
  tmp_enabled = ANDIF ((x), NOTBI (CPU (h_sbit)));\
215
CPU (h_sbit) = (x);\
216
if (tmp_enabled) {\
217
crisv32f_single_step_enabled (current_cpu);\
218
}\
219
}\
220
}\
221
}\
222
;} while (0)
223
  } hardware;
224
#define CPU_CGEN_HW(cpu) (& (cpu)->cpu_data.hardware)
225
} CRISV32F_CPU_DATA;
226
 
227
/* Virtual regs.  */
228
 
229
#define GET_H_V32_V32() 1
230
#define SET_H_V32_V32(x) \
231
do { \
232
cgen_rtx_error (current_cpu, "Can't set h-v32");\
233
;} while (0)
234
#define GET_H_GR(index) CPU (h_gr_acr[index])
235
#define SET_H_GR(index, x) \
236
do { \
237
CPU (h_gr_acr[(index)]) = (x);\
238
;} while (0)
239
#define GET_H_RAW_GR_ACR(index) CPU (h_gr_acr[index])
240
#define SET_H_RAW_GR_ACR(index, x) \
241
do { \
242
CPU (h_gr_acr[(index)]) = (x);\
243
;} while (0)
244
#define GET_H_SR(index) GET_H_SR_V32 (index)
245
#define SET_H_SR(index, x) \
246
do { \
247
SET_H_SR_V32 ((index), (x));\
248
;} while (0)
249
#define GET_H_SUPR(index) crisv32f_read_supr (current_cpu, index)
250
#define SET_H_SUPR(index, x) \
251
do { \
252
crisv32f_write_supr (current_cpu, (index), (x));\
253
;} while (0)
254
#define GET_H_CBIT_MOVE() GET_H_CBIT_MOVE_V32 ()
255
#define SET_H_CBIT_MOVE(x) \
256
do { \
257
SET_H_CBIT_MOVE_V32 ((x));\
258
;} while (0)
259
#define GET_H_CBIT_MOVE_V32() (cgen_rtx_error (current_cpu, "Can't get h-cbit-move on CRISv32"), 0)
260
#define SET_H_CBIT_MOVE_V32(x) \
261
do { \
262
((void) 0); /*nop*/\
263
;} while (0)
264
#define GET_H_VBIT_MOVE() GET_H_VBIT_MOVE_V32 ()
265
#define SET_H_VBIT_MOVE(x) \
266
do { \
267
SET_H_VBIT_MOVE_V32 ((x));\
268
;} while (0)
269
#define GET_H_VBIT_MOVE_V32() (cgen_rtx_error (current_cpu, "Can't get h-vbit-move on CRISv32"), 0)
270
#define SET_H_VBIT_MOVE_V32(x) \
271
do { \
272
((void) 0); /*nop*/\
273
;} while (0)
274
#define GET_H_ZBIT_MOVE() GET_H_ZBIT_MOVE_V32 ()
275
#define SET_H_ZBIT_MOVE(x) \
276
do { \
277
SET_H_ZBIT_MOVE_V32 ((x));\
278
;} while (0)
279
#define GET_H_ZBIT_MOVE_V32() (cgen_rtx_error (current_cpu, "Can't get h-zbit-move on CRISv32"), 0)
280
#define SET_H_ZBIT_MOVE_V32(x) \
281
do { \
282
((void) 0); /*nop*/\
283
;} while (0)
284
#define GET_H_NBIT_MOVE() GET_H_NBIT_MOVE_V32 ()
285
#define SET_H_NBIT_MOVE(x) \
286
do { \
287
SET_H_NBIT_MOVE_V32 ((x));\
288
;} while (0)
289
#define GET_H_NBIT_MOVE_V32() (cgen_rtx_error (current_cpu, "Can't get h-nbit-move on CRISv32"), 0)
290
#define SET_H_NBIT_MOVE_V32(x) \
291
do { \
292
((void) 0); /*nop*/\
293
;} while (0)
294
#define GET_H_IBIT() CPU (h_ibit_v32)
295
#define SET_H_IBIT(x) \
296
do { \
297
SET_H_IBIT_V32 ((x));\
298
;} while (0)
299
#define GET_H_UBIT() CPU (h_ubit_v32)
300
#define SET_H_UBIT(x) \
301
do { \
302
SET_H_UBIT_V32 ((x));\
303
;} while (0)
304
#define GET_H_INSN_PREFIXED_P() GET_H_INSN_PREFIXED_P_V32 ()
305
#define SET_H_INSN_PREFIXED_P(x) \
306
do { \
307
SET_H_INSN_PREFIXED_P_V32 ((x));\
308
;} while (0)
309
#define GET_H_INSN_PREFIXED_P_V32() 0
310
#define SET_H_INSN_PREFIXED_P_V32(x) \
311
do { \
312
((void) 0); /*nop*/\
313
;} while (0)
314
#define GET_H_PREFIXREG_V32() GET_H_GR (((UINT) 15))
315
#define SET_H_PREFIXREG_V32(x) \
316
do { \
317
SET_H_GR (((UINT) 15), (x));\
318
;} while (0)
319
 
320
/* Cover fns for register access.  */
321
BI crisv32f_h_v32_v32_get (SIM_CPU *);
322
void crisv32f_h_v32_v32_set (SIM_CPU *, BI);
323
USI crisv32f_h_pc_get (SIM_CPU *);
324
void crisv32f_h_pc_set (SIM_CPU *, USI);
325
SI crisv32f_h_gr_get (SIM_CPU *, UINT);
326
void crisv32f_h_gr_set (SIM_CPU *, UINT, SI);
327
SI crisv32f_h_gr_acr_get (SIM_CPU *, UINT);
328
void crisv32f_h_gr_acr_set (SIM_CPU *, UINT, SI);
329
SI crisv32f_h_raw_gr_acr_get (SIM_CPU *, UINT);
330
void crisv32f_h_raw_gr_acr_set (SIM_CPU *, UINT, SI);
331
SI crisv32f_h_sr_get (SIM_CPU *, UINT);
332
void crisv32f_h_sr_set (SIM_CPU *, UINT, SI);
333
SI crisv32f_h_sr_v32_get (SIM_CPU *, UINT);
334
void crisv32f_h_sr_v32_set (SIM_CPU *, UINT, SI);
335
SI crisv32f_h_supr_get (SIM_CPU *, UINT);
336
void crisv32f_h_supr_set (SIM_CPU *, UINT, SI);
337
BI crisv32f_h_cbit_get (SIM_CPU *);
338
void crisv32f_h_cbit_set (SIM_CPU *, BI);
339
BI crisv32f_h_cbit_move_get (SIM_CPU *);
340
void crisv32f_h_cbit_move_set (SIM_CPU *, BI);
341
BI crisv32f_h_cbit_move_v32_get (SIM_CPU *);
342
void crisv32f_h_cbit_move_v32_set (SIM_CPU *, BI);
343
BI crisv32f_h_vbit_get (SIM_CPU *);
344
void crisv32f_h_vbit_set (SIM_CPU *, BI);
345
BI crisv32f_h_vbit_move_get (SIM_CPU *);
346
void crisv32f_h_vbit_move_set (SIM_CPU *, BI);
347
BI crisv32f_h_vbit_move_v32_get (SIM_CPU *);
348
void crisv32f_h_vbit_move_v32_set (SIM_CPU *, BI);
349
BI crisv32f_h_zbit_get (SIM_CPU *);
350
void crisv32f_h_zbit_set (SIM_CPU *, BI);
351
BI crisv32f_h_zbit_move_get (SIM_CPU *);
352
void crisv32f_h_zbit_move_set (SIM_CPU *, BI);
353
BI crisv32f_h_zbit_move_v32_get (SIM_CPU *);
354
void crisv32f_h_zbit_move_v32_set (SIM_CPU *, BI);
355
BI crisv32f_h_nbit_get (SIM_CPU *);
356
void crisv32f_h_nbit_set (SIM_CPU *, BI);
357
BI crisv32f_h_nbit_move_get (SIM_CPU *);
358
void crisv32f_h_nbit_move_set (SIM_CPU *, BI);
359
BI crisv32f_h_nbit_move_v32_get (SIM_CPU *);
360
void crisv32f_h_nbit_move_v32_set (SIM_CPU *, BI);
361
BI crisv32f_h_xbit_get (SIM_CPU *);
362
void crisv32f_h_xbit_set (SIM_CPU *, BI);
363
BI crisv32f_h_ibit_get (SIM_CPU *);
364
void crisv32f_h_ibit_set (SIM_CPU *, BI);
365
BI crisv32f_h_pbit_get (SIM_CPU *);
366
void crisv32f_h_pbit_set (SIM_CPU *, BI);
367
BI crisv32f_h_rbit_get (SIM_CPU *);
368
void crisv32f_h_rbit_set (SIM_CPU *, BI);
369
BI crisv32f_h_ubit_get (SIM_CPU *);
370
void crisv32f_h_ubit_set (SIM_CPU *, BI);
371
BI crisv32f_h_gbit_get (SIM_CPU *);
372
void crisv32f_h_gbit_set (SIM_CPU *, BI);
373
SI crisv32f_h_kernel_sp_get (SIM_CPU *);
374
void crisv32f_h_kernel_sp_set (SIM_CPU *, SI);
375
BI crisv32f_h_ubit_v32_get (SIM_CPU *);
376
void crisv32f_h_ubit_v32_set (SIM_CPU *, BI);
377
BI crisv32f_h_ibit_v32_get (SIM_CPU *);
378
void crisv32f_h_ibit_v32_set (SIM_CPU *, BI);
379
BI crisv32f_h_mbit_get (SIM_CPU *);
380
void crisv32f_h_mbit_set (SIM_CPU *, BI);
381
BI crisv32f_h_qbit_get (SIM_CPU *);
382
void crisv32f_h_qbit_set (SIM_CPU *, BI);
383
BI crisv32f_h_sbit_get (SIM_CPU *);
384
void crisv32f_h_sbit_set (SIM_CPU *, BI);
385
BI crisv32f_h_insn_prefixed_p_get (SIM_CPU *);
386
void crisv32f_h_insn_prefixed_p_set (SIM_CPU *, BI);
387
BI crisv32f_h_insn_prefixed_p_v32_get (SIM_CPU *);
388
void crisv32f_h_insn_prefixed_p_v32_set (SIM_CPU *, BI);
389
SI crisv32f_h_prefixreg_v32_get (SIM_CPU *);
390
void crisv32f_h_prefixreg_v32_set (SIM_CPU *, SI);
391
 
392
/* These must be hand-written.  */
393
extern CPUREG_FETCH_FN crisv32f_fetch_register;
394
extern CPUREG_STORE_FN crisv32f_store_register;
395
 
396
typedef struct {
397
  UINT prev_prev_prev_modf_regs;
398
  UINT prev_prev_modf_regs;
399
  UINT prev_modf_regs;
400
  UINT modf_regs;
401
  UINT prev_prev_prev_movem_dest_regs;
402
  UINT prev_prev_movem_dest_regs;
403
  UINT prev_movem_dest_regs;
404
  UINT movem_dest_regs;
405
} MODEL_CRISV32_DATA;
406
 
407
/* Instruction argument buffer.  */
408
 
409
union sem_fields {
410
  struct { /* no operands */
411
    int empty;
412
  } fmt_empty;
413
  struct { /*  */
414
    UINT f_u4;
415
  } sfmt_break;
416
  struct { /*  */
417
    UINT f_dstsrc;
418
  } sfmt_setf;
419
  struct { /*  */
420
    IADDR i_o_word_pcrel;
421
    UINT f_operand2;
422
  } sfmt_bcc_w;
423
  struct { /*  */
424
    IADDR i_o_pcrel;
425
    UINT f_operand2;
426
  } sfmt_bcc_b;
427
  struct { /*  */
428
    unsigned char in_h_sr_SI_13;
429
    unsigned char out_h_sr_SI_13;
430
  } sfmt_rfe;
431
  struct { /*  */
432
    INT f_s8;
433
    UINT f_operand2;
434
    unsigned char in_Rd;
435
  } sfmt_addoq;
436
  struct { /*  */
437
    ADDR i_const32_pcrel;
438
    UINT f_operand2;
439
    unsigned char out_Pd;
440
  } sfmt_bas_c;
441
  struct { /*  */
442
    ADDR i_qo;
443
    UINT f_operand2;
444
    unsigned char out_Rd;
445
  } sfmt_lapcq;
446
  struct { /*  */
447
    ADDR i_const32_pcrel;
448
    UINT f_operand2;
449
    unsigned char out_Rd;
450
  } sfmt_lapc_d;
451
  struct { /*  */
452
    INT f_indir_pc__dword;
453
    UINT f_operand2;
454
    unsigned char out_Pd;
455
  } sfmt_move_c_sprv32_p2;
456
  struct { /*  */
457
    INT f_s6;
458
    UINT f_operand2;
459
    unsigned char out_Rd;
460
  } sfmt_moveq;
461
  struct { /*  */
462
    INT f_indir_pc__dword;
463
    UINT f_operand2;
464
    unsigned char in_Rd;
465
    unsigned char out_Rd;
466
  } sfmt_bound_cd;
467
  struct { /*  */
468
    INT f_indir_pc__word;
469
    UINT f_operand2;
470
    unsigned char in_Rd;
471
    unsigned char out_Rd;
472
  } sfmt_bound_cw;
473
  struct { /*  */
474
    INT f_indir_pc__byte;
475
    UINT f_operand2;
476
    unsigned char in_Rd;
477
    unsigned char out_Rd;
478
  } sfmt_bound_cb;
479
  struct { /*  */
480
    UINT f_operand2;
481
    UINT f_u5;
482
    unsigned char in_Rd;
483
    unsigned char out_Rd;
484
  } sfmt_asrq;
485
  struct { /*  */
486
    INT f_s6;
487
    UINT f_operand2;
488
    unsigned char in_Rd;
489
    unsigned char out_h_gr_SI_index_of__DFLT_Rd;
490
  } sfmt_andq;
491
  struct { /*  */
492
    INT f_indir_pc__dword;
493
    UINT f_operand2;
494
    unsigned char in_Rd;
495
    unsigned char out_h_gr_SI_index_of__DFLT_Rd;
496
  } sfmt_addcdr;
497
  struct { /*  */
498
    INT f_indir_pc__word;
499
    UINT f_operand2;
500
    unsigned char in_Rd;
501
    unsigned char out_h_gr_SI_index_of__DFLT_Rd;
502
  } sfmt_addcwr;
503
  struct { /*  */
504
    INT f_indir_pc__byte;
505
    UINT f_operand2;
506
    unsigned char in_Rd;
507
    unsigned char out_h_gr_SI_index_of__DFLT_Rd;
508
  } sfmt_addcbr;
509
  struct { /*  */
510
    UINT f_operand2;
511
    UINT f_u6;
512
    unsigned char in_Rd;
513
    unsigned char out_h_gr_SI_index_of__DFLT_Rd;
514
  } sfmt_addq;
515
  struct { /*  */
516
    UINT f_operand1;
517
    UINT f_operand2;
518
    unsigned char in_Ps;
519
    unsigned char in_Rs;
520
    unsigned char out_h_gr_SI_index_of__DFLT_Rs;
521
  } sfmt_mcp;
522
  struct { /*  */
523
    UINT f_operand1;
524
    UINT f_operand2;
525
    unsigned char in_Rd;
526
    unsigned char in_Rs;
527
    unsigned char out_Rd;
528
    unsigned char out_h_sr_SI_7;
529
  } sfmt_muls_b;
530
  struct { /*  */
531
    UINT f_memmode;
532
    UINT f_operand1;
533
    UINT f_operand2;
534
    unsigned char in_Ps;
535
    unsigned char in_Rs;
536
    unsigned char out_Rs;
537
  } sfmt_move_spr_mv32;
538
  struct { /*  */
539
    UINT f_memmode;
540
    UINT f_operand1;
541
    UINT f_operand2;
542
    unsigned char in_Rs;
543
    unsigned char out_Pd;
544
    unsigned char out_Rs;
545
  } sfmt_move_m_sprv32;
546
  struct { /*  */
547
    UINT f_memmode;
548
    UINT f_operand1;
549
    UINT f_operand2;
550
    unsigned char in_Rs;
551
    unsigned char out_Rd;
552
    unsigned char out_Rs;
553
  } sfmt_movs_m_b_m;
554
  struct { /*  */
555
    UINT f_memmode;
556
    UINT f_operand1;
557
    UINT f_operand2;
558
    unsigned char in_Rd;
559
    unsigned char in_Rs;
560
    unsigned char out_Rs;
561
    unsigned char out_h_gr_SI_index_of__DFLT_Rd;
562
  } sfmt_addc_m;
563
  struct { /*  */
564
    UINT f_memmode;
565
    UINT f_operand1;
566
    UINT f_operand2;
567
    unsigned char in_Rd;
568
    unsigned char in_Rs;
569
    unsigned char out_Rs;
570
    unsigned char out_h_gr_SI_if__SI_andif__DFLT_prefix_set_not__DFLT_inc_index_of__DFLT_Rs_index_of__DFLT_Rd;
571
  } sfmt_add_m_b_m;
572
  struct { /*  */
573
    UINT f_memmode;
574
    UINT f_operand1;
575
    UINT f_operand2;
576
    unsigned char in_Rd;
577
    unsigned char in_Rs;
578
    unsigned char out_Rs;
579
    unsigned char out_h_gr_SI_0;
580
    unsigned char out_h_gr_SI_1;
581
    unsigned char out_h_gr_SI_10;
582
    unsigned char out_h_gr_SI_11;
583
    unsigned char out_h_gr_SI_12;
584
    unsigned char out_h_gr_SI_13;
585
    unsigned char out_h_gr_SI_14;
586
    unsigned char out_h_gr_SI_15;
587
    unsigned char out_h_gr_SI_2;
588
    unsigned char out_h_gr_SI_3;
589
    unsigned char out_h_gr_SI_4;
590
    unsigned char out_h_gr_SI_5;
591
    unsigned char out_h_gr_SI_6;
592
    unsigned char out_h_gr_SI_7;
593
    unsigned char out_h_gr_SI_8;
594
    unsigned char out_h_gr_SI_9;
595
  } sfmt_movem_m_r_v32;
596
  struct { /*  */
597
    UINT f_memmode;
598
    UINT f_operand1;
599
    UINT f_operand2;
600
    unsigned char in_Rd;
601
    unsigned char in_Rs;
602
    unsigned char in_h_gr_SI_0;
603
    unsigned char in_h_gr_SI_1;
604
    unsigned char in_h_gr_SI_10;
605
    unsigned char in_h_gr_SI_11;
606
    unsigned char in_h_gr_SI_12;
607
    unsigned char in_h_gr_SI_13;
608
    unsigned char in_h_gr_SI_14;
609
    unsigned char in_h_gr_SI_15;
610
    unsigned char in_h_gr_SI_2;
611
    unsigned char in_h_gr_SI_3;
612
    unsigned char in_h_gr_SI_4;
613
    unsigned char in_h_gr_SI_5;
614
    unsigned char in_h_gr_SI_6;
615
    unsigned char in_h_gr_SI_7;
616
    unsigned char in_h_gr_SI_8;
617
    unsigned char in_h_gr_SI_9;
618
    unsigned char out_Rs;
619
  } sfmt_movem_r_m_v32;
620
#if WITH_SCACHE_PBB
621
  /* Writeback handler.  */
622
  struct {
623
    /* Pointer to argbuf entry for insn whose results need writing back.  */
624
    const struct argbuf *abuf;
625
  } write;
626
  /* x-before handler */
627
  struct {
628
    /*const SCACHE *insns[MAX_PARALLEL_INSNS];*/
629
    int first_p;
630
  } before;
631
  /* x-after handler */
632
  struct {
633
    int empty;
634
  } after;
635
  /* This entry is used to terminate each pbb.  */
636
  struct {
637
    /* Number of insns in pbb.  */
638
    int insn_count;
639
    /* Next pbb to execute.  */
640
    SCACHE *next;
641
    SCACHE *branch_target;
642
  } chain;
643
#endif
644
};
645
 
646
/* The ARGBUF struct.  */
647
struct argbuf {
648
  /* These are the baseclass definitions.  */
649
  IADDR addr;
650
  const IDESC *idesc;
651
  char trace_p;
652
  char profile_p;
653
  /* ??? Temporary hack for skip insns.  */
654
  char skip_count;
655
  char unused;
656
  /* cpu specific data follows */
657
  union sem semantic;
658
  int written;
659
  union sem_fields fields;
660
};
661
 
662
/* A cached insn.
663
 
664
   ??? SCACHE used to contain more than just argbuf.  We could delete the
665
   type entirely and always just use ARGBUF, but for future concerns and as
666
   a level of abstraction it is left in.  */
667
 
668
struct scache {
669
  struct argbuf argbuf;
670
};
671
 
672
/* Macros to simplify extraction, reading and semantic code.
673
   These define and assign the local vars that contain the insn's fields.  */
674
 
675
#define EXTRACT_IFMT_EMPTY_VARS \
676
  unsigned int length;
677
#define EXTRACT_IFMT_EMPTY_CODE \
678
  length = 0; \
679
 
680
#define EXTRACT_IFMT_MOVE_B_R_VARS \
681
  UINT f_operand2; \
682
  UINT f_mode; \
683
  UINT f_opcode; \
684
  UINT f_size; \
685
  UINT f_operand1; \
686
  unsigned int length;
687
#define EXTRACT_IFMT_MOVE_B_R_CODE \
688
  length = 2; \
689
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
690
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
691
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
692
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
693
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
694
 
695
#define EXTRACT_IFMT_MOVEQ_VARS \
696
  UINT f_operand2; \
697
  UINT f_mode; \
698
  UINT f_opcode; \
699
  INT f_s6; \
700
  unsigned int length;
701
#define EXTRACT_IFMT_MOVEQ_CODE \
702
  length = 2; \
703
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
704
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
705
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
706
  f_s6 = EXTRACT_LSB0_INT (insn, 16, 5, 6); \
707
 
708
#define EXTRACT_IFMT_MOVECBR_VARS \
709
  UINT f_operand2; \
710
  INT f_indir_pc__byte; \
711
  UINT f_mode; \
712
  UINT f_opcode; \
713
  UINT f_size; \
714
  UINT f_operand1; \
715
  /* Contents of trailing part of insn.  */ \
716
  UINT word_1; \
717
  unsigned int length;
718
#define EXTRACT_IFMT_MOVECBR_CODE \
719
  length = 4; \
720
  word_1 = GETIMEMUSI (current_cpu, pc + 2); \
721
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
722
  f_indir_pc__byte = (0|(EXTRACT_LSB0_UINT (word_1, 32, 15, 16) << 0)); \
723
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
724
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
725
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
726
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
727
 
728
#define EXTRACT_IFMT_MOVECWR_VARS \
729
  UINT f_operand2; \
730
  INT f_indir_pc__word; \
731
  UINT f_mode; \
732
  UINT f_opcode; \
733
  UINT f_size; \
734
  UINT f_operand1; \
735
  /* Contents of trailing part of insn.  */ \
736
  UINT word_1; \
737
  unsigned int length;
738
#define EXTRACT_IFMT_MOVECWR_CODE \
739
  length = 4; \
740
  word_1 = GETIMEMUSI (current_cpu, pc + 2); \
741
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
742
  f_indir_pc__word = (0|(EXTRACT_LSB0_UINT (word_1, 32, 15, 16) << 0)); \
743
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
744
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
745
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
746
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
747
 
748
#define EXTRACT_IFMT_MOVECDR_VARS \
749
  INT f_indir_pc__dword; \
750
  UINT f_operand2; \
751
  UINT f_mode; \
752
  UINT f_opcode; \
753
  UINT f_size; \
754
  UINT f_operand1; \
755
  /* Contents of trailing part of insn.  */ \
756
  UINT word_1; \
757
  unsigned int length;
758
#define EXTRACT_IFMT_MOVECDR_CODE \
759
  length = 6; \
760
  word_1 = GETIMEMUSI (current_cpu, pc + 2); \
761
  f_indir_pc__dword = (0|(EXTRACT_LSB0_UINT (word_1, 32, 31, 32) << 0)); \
762
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
763
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
764
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
765
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
766
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
767
 
768
#define EXTRACT_IFMT_MOVUCBR_VARS \
769
  UINT f_operand2; \
770
  INT f_indir_pc__byte; \
771
  UINT f_mode; \
772
  UINT f_opcode; \
773
  UINT f_size; \
774
  UINT f_operand1; \
775
  /* Contents of trailing part of insn.  */ \
776
  UINT word_1; \
777
  unsigned int length;
778
#define EXTRACT_IFMT_MOVUCBR_CODE \
779
  length = 4; \
780
  word_1 = GETIMEMUSI (current_cpu, pc + 2); \
781
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
782
  f_indir_pc__byte = (0|(EXTRACT_LSB0_UINT (word_1, 32, 15, 16) << 0)); \
783
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
784
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
785
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
786
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
787
 
788
#define EXTRACT_IFMT_MOVUCWR_VARS \
789
  UINT f_operand2; \
790
  INT f_indir_pc__word; \
791
  UINT f_mode; \
792
  UINT f_opcode; \
793
  UINT f_size; \
794
  UINT f_operand1; \
795
  /* Contents of trailing part of insn.  */ \
796
  UINT word_1; \
797
  unsigned int length;
798
#define EXTRACT_IFMT_MOVUCWR_CODE \
799
  length = 4; \
800
  word_1 = GETIMEMUSI (current_cpu, pc + 2); \
801
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
802
  f_indir_pc__word = (0|(EXTRACT_LSB0_UINT (word_1, 32, 15, 16) << 0)); \
803
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
804
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
805
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
806
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
807
 
808
#define EXTRACT_IFMT_ADDQ_VARS \
809
  UINT f_operand2; \
810
  UINT f_mode; \
811
  UINT f_opcode; \
812
  UINT f_u6; \
813
  unsigned int length;
814
#define EXTRACT_IFMT_ADDQ_CODE \
815
  length = 2; \
816
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
817
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
818
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
819
  f_u6 = EXTRACT_LSB0_UINT (insn, 16, 5, 6); \
820
 
821
#define EXTRACT_IFMT_CMP_M_B_M_VARS \
822
  UINT f_operand2; \
823
  UINT f_membit; \
824
  UINT f_memmode; \
825
  UINT f_opcode; \
826
  UINT f_size; \
827
  UINT f_operand1; \
828
  unsigned int length;
829
#define EXTRACT_IFMT_CMP_M_B_M_CODE \
830
  length = 2; \
831
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
832
  f_membit = EXTRACT_LSB0_UINT (insn, 16, 11, 1); \
833
  f_memmode = EXTRACT_LSB0_UINT (insn, 16, 10, 1); \
834
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
835
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
836
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
837
 
838
#define EXTRACT_IFMT_MOVE_R_SPRV32_VARS \
839
  UINT f_operand2; \
840
  UINT f_mode; \
841
  UINT f_opcode; \
842
  UINT f_size; \
843
  UINT f_operand1; \
844
  unsigned int length;
845
#define EXTRACT_IFMT_MOVE_R_SPRV32_CODE \
846
  length = 2; \
847
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
848
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
849
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
850
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
851
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
852
 
853
#define EXTRACT_IFMT_MOVE_SPR_RV32_VARS \
854
  UINT f_operand2; \
855
  UINT f_mode; \
856
  UINT f_opcode; \
857
  UINT f_size; \
858
  UINT f_operand1; \
859
  unsigned int length;
860
#define EXTRACT_IFMT_MOVE_SPR_RV32_CODE \
861
  length = 2; \
862
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
863
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
864
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
865
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
866
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
867
 
868
#define EXTRACT_IFMT_MOVE_M_SPRV32_VARS \
869
  UINT f_operand2; \
870
  UINT f_membit; \
871
  UINT f_memmode; \
872
  UINT f_opcode; \
873
  UINT f_size; \
874
  UINT f_operand1; \
875
  unsigned int length;
876
#define EXTRACT_IFMT_MOVE_M_SPRV32_CODE \
877
  length = 2; \
878
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
879
  f_membit = EXTRACT_LSB0_UINT (insn, 16, 11, 1); \
880
  f_memmode = EXTRACT_LSB0_UINT (insn, 16, 10, 1); \
881
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
882
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
883
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
884
 
885
#define EXTRACT_IFMT_MOVE_C_SPRV32_P2_VARS \
886
  INT f_indir_pc__dword; \
887
  UINT f_operand2; \
888
  UINT f_mode; \
889
  UINT f_opcode; \
890
  UINT f_size; \
891
  UINT f_operand1; \
892
  /* Contents of trailing part of insn.  */ \
893
  UINT word_1; \
894
  unsigned int length;
895
#define EXTRACT_IFMT_MOVE_C_SPRV32_P2_CODE \
896
  length = 6; \
897
  word_1 = GETIMEMUSI (current_cpu, pc + 2); \
898
  f_indir_pc__dword = (0|(EXTRACT_LSB0_UINT (word_1, 32, 31, 32) << 0)); \
899
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
900
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
901
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
902
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
903
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
904
 
905
#define EXTRACT_IFMT_MOVE_SPR_MV32_VARS \
906
  UINT f_operand2; \
907
  UINT f_membit; \
908
  UINT f_memmode; \
909
  UINT f_opcode; \
910
  UINT f_size; \
911
  UINT f_operand1; \
912
  unsigned int length;
913
#define EXTRACT_IFMT_MOVE_SPR_MV32_CODE \
914
  length = 2; \
915
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
916
  f_membit = EXTRACT_LSB0_UINT (insn, 16, 11, 1); \
917
  f_memmode = EXTRACT_LSB0_UINT (insn, 16, 10, 1); \
918
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
919
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
920
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
921
 
922
#define EXTRACT_IFMT_MOVE_SS_R_VARS \
923
  UINT f_operand2; \
924
  UINT f_mode; \
925
  UINT f_opcode; \
926
  UINT f_size; \
927
  UINT f_operand1; \
928
  unsigned int length;
929
#define EXTRACT_IFMT_MOVE_SS_R_CODE \
930
  length = 2; \
931
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
932
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
933
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
934
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
935
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
936
 
937
#define EXTRACT_IFMT_MOVE_R_SS_VARS \
938
  UINT f_operand2; \
939
  UINT f_mode; \
940
  UINT f_opcode; \
941
  UINT f_size; \
942
  UINT f_operand1; \
943
  unsigned int length;
944
#define EXTRACT_IFMT_MOVE_R_SS_CODE \
945
  length = 2; \
946
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
947
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
948
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
949
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
950
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
951
 
952
#define EXTRACT_IFMT_LAPC_D_VARS \
953
  SI f_indir_pc__dword_pcrel; \
954
  UINT f_operand2; \
955
  UINT f_mode; \
956
  UINT f_opcode; \
957
  UINT f_size; \
958
  UINT f_operand1; \
959
  /* Contents of trailing part of insn.  */ \
960
  UINT word_1; \
961
  unsigned int length;
962
#define EXTRACT_IFMT_LAPC_D_CODE \
963
  length = 6; \
964
  word_1 = GETIMEMUSI (current_cpu, pc + 2); \
965
  f_indir_pc__dword_pcrel = ((pc) + ((0|(EXTRACT_LSB0_UINT (word_1, 32, 31, 32) << 0)))); \
966
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
967
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
968
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
969
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
970
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
971
 
972
#define EXTRACT_IFMT_LAPCQ_VARS \
973
  UINT f_operand2; \
974
  UINT f_mode; \
975
  UINT f_opcode; \
976
  UINT f_size; \
977
  SI f_qo; \
978
  unsigned int length;
979
#define EXTRACT_IFMT_LAPCQ_CODE \
980
  length = 2; \
981
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
982
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
983
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
984
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
985
  f_qo = ((pc) + (((EXTRACT_LSB0_UINT (insn, 16, 3, 4)) << (1)))); \
986
 
987
#define EXTRACT_IFMT_TEST_M_B_M_VARS \
988
  UINT f_operand2; \
989
  UINT f_membit; \
990
  UINT f_memmode; \
991
  UINT f_opcode; \
992
  UINT f_size; \
993
  UINT f_operand1; \
994
  unsigned int length;
995
#define EXTRACT_IFMT_TEST_M_B_M_CODE \
996
  length = 2; \
997
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
998
  f_membit = EXTRACT_LSB0_UINT (insn, 16, 11, 1); \
999
  f_memmode = EXTRACT_LSB0_UINT (insn, 16, 10, 1); \
1000
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
1001
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
1002
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
1003
 
1004
#define EXTRACT_IFMT_SWAP_VARS \
1005
  UINT f_operand2; \
1006
  UINT f_mode; \
1007
  UINT f_opcode; \
1008
  UINT f_size; \
1009
  UINT f_operand1; \
1010
  unsigned int length;
1011
#define EXTRACT_IFMT_SWAP_CODE \
1012
  length = 2; \
1013
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
1014
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
1015
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
1016
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
1017
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
1018
 
1019
#define EXTRACT_IFMT_ASRQ_VARS \
1020
  UINT f_operand2; \
1021
  UINT f_mode; \
1022
  UINT f_opcode; \
1023
  UINT f_b5; \
1024
  UINT f_u5; \
1025
  unsigned int length;
1026
#define EXTRACT_IFMT_ASRQ_CODE \
1027
  length = 2; \
1028
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
1029
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
1030
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
1031
  f_b5 = EXTRACT_LSB0_UINT (insn, 16, 5, 1); \
1032
  f_u5 = EXTRACT_LSB0_UINT (insn, 16, 4, 5); \
1033
 
1034
#define EXTRACT_IFMT_SETF_VARS \
1035
  UINT f_mode; \
1036
  UINT f_opcode; \
1037
  UINT f_size; \
1038
  UINT f_operand2; \
1039
  UINT f_operand1; \
1040
  UINT f_dstsrc; \
1041
  unsigned int length;
1042
#define EXTRACT_IFMT_SETF_CODE \
1043
  length = 2; \
1044
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
1045
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
1046
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
1047
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
1048
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
1049
  f_dstsrc = ((((f_operand1) | (((f_operand2) << (4))))) & (255));\
1050
 
1051
#define EXTRACT_IFMT_RFE_VARS \
1052
  UINT f_operand2; \
1053
  UINT f_mode; \
1054
  UINT f_opcode; \
1055
  UINT f_size; \
1056
  UINT f_operand1; \
1057
  unsigned int length;
1058
#define EXTRACT_IFMT_RFE_CODE \
1059
  length = 2; \
1060
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
1061
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
1062
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
1063
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
1064
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
1065
 
1066
#define EXTRACT_IFMT_BCC_B_VARS \
1067
  UINT f_operand2; \
1068
  UINT f_mode; \
1069
  UINT f_opcode_hi; \
1070
  INT f_disp9_hi; \
1071
  UINT f_disp9_lo; \
1072
  INT f_disp9; \
1073
  unsigned int length;
1074
#define EXTRACT_IFMT_BCC_B_CODE \
1075
  length = 2; \
1076
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
1077
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
1078
  f_opcode_hi = EXTRACT_LSB0_UINT (insn, 16, 9, 2); \
1079
  f_disp9_hi = EXTRACT_LSB0_INT (insn, 16, 0, 1); \
1080
  f_disp9_lo = EXTRACT_LSB0_UINT (insn, 16, 7, 7); \
1081
{\
1082
  SI tmp_abslo;\
1083
  SI tmp_absval;\
1084
  tmp_abslo = ((f_disp9_lo) << (1));\
1085
  tmp_absval = ((((((f_disp9_hi) != (0))) ? ((~ (255))) : (0))) | (tmp_abslo));\
1086
  f_disp9 = ((((pc) + (tmp_absval))) + (((GET_H_V32_V32 ()) ? (0) : (2))));\
1087
}\
1088
 
1089
#define EXTRACT_IFMT_BA_B_VARS \
1090
  UINT f_operand2; \
1091
  UINT f_mode; \
1092
  UINT f_opcode_hi; \
1093
  INT f_disp9_hi; \
1094
  UINT f_disp9_lo; \
1095
  INT f_disp9; \
1096
  unsigned int length;
1097
#define EXTRACT_IFMT_BA_B_CODE \
1098
  length = 2; \
1099
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
1100
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
1101
  f_opcode_hi = EXTRACT_LSB0_UINT (insn, 16, 9, 2); \
1102
  f_disp9_hi = EXTRACT_LSB0_INT (insn, 16, 0, 1); \
1103
  f_disp9_lo = EXTRACT_LSB0_UINT (insn, 16, 7, 7); \
1104
{\
1105
  SI tmp_abslo;\
1106
  SI tmp_absval;\
1107
  tmp_abslo = ((f_disp9_lo) << (1));\
1108
  tmp_absval = ((((((f_disp9_hi) != (0))) ? ((~ (255))) : (0))) | (tmp_abslo));\
1109
  f_disp9 = ((((pc) + (tmp_absval))) + (((GET_H_V32_V32 ()) ? (0) : (2))));\
1110
}\
1111
 
1112
#define EXTRACT_IFMT_BCC_W_VARS \
1113
  UINT f_operand2; \
1114
  SI f_indir_pc__word_pcrel; \
1115
  UINT f_mode; \
1116
  UINT f_opcode; \
1117
  UINT f_size; \
1118
  UINT f_operand1; \
1119
  /* Contents of trailing part of insn.  */ \
1120
  UINT word_1; \
1121
  unsigned int length;
1122
#define EXTRACT_IFMT_BCC_W_CODE \
1123
  length = 4; \
1124
  word_1 = GETIMEMUSI (current_cpu, pc + 2); \
1125
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
1126
  f_indir_pc__word_pcrel = ((EXTHISI (((HI) (UINT) ((0|(EXTRACT_LSB0_UINT (word_1, 32, 15, 16) << 0)))))) + (((pc) + (((GET_H_V32_V32 ()) ? (0) : (4)))))); \
1127
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
1128
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
1129
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
1130
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
1131
 
1132
#define EXTRACT_IFMT_BA_W_VARS \
1133
  UINT f_operand2; \
1134
  SI f_indir_pc__word_pcrel; \
1135
  UINT f_mode; \
1136
  UINT f_opcode; \
1137
  UINT f_size; \
1138
  UINT f_operand1; \
1139
  /* Contents of trailing part of insn.  */ \
1140
  UINT word_1; \
1141
  unsigned int length;
1142
#define EXTRACT_IFMT_BA_W_CODE \
1143
  length = 4; \
1144
  word_1 = GETIMEMUSI (current_cpu, pc + 2); \
1145
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
1146
  f_indir_pc__word_pcrel = ((EXTHISI (((HI) (UINT) ((0|(EXTRACT_LSB0_UINT (word_1, 32, 15, 16) << 0)))))) + (((pc) + (((GET_H_V32_V32 ()) ? (0) : (4)))))); \
1147
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
1148
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
1149
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
1150
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
1151
 
1152
#define EXTRACT_IFMT_JAS_C_VARS \
1153
  INT f_indir_pc__dword; \
1154
  UINT f_operand2; \
1155
  UINT f_mode; \
1156
  UINT f_opcode; \
1157
  UINT f_size; \
1158
  UINT f_operand1; \
1159
  /* Contents of trailing part of insn.  */ \
1160
  UINT word_1; \
1161
  unsigned int length;
1162
#define EXTRACT_IFMT_JAS_C_CODE \
1163
  length = 6; \
1164
  word_1 = GETIMEMUSI (current_cpu, pc + 2); \
1165
  f_indir_pc__dword = (0|(EXTRACT_LSB0_UINT (word_1, 32, 31, 32) << 0)); \
1166
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
1167
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
1168
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
1169
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
1170
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
1171
 
1172
#define EXTRACT_IFMT_JUMP_P_VARS \
1173
  UINT f_operand2; \
1174
  UINT f_mode; \
1175
  UINT f_opcode; \
1176
  UINT f_size; \
1177
  UINT f_operand1; \
1178
  unsigned int length;
1179
#define EXTRACT_IFMT_JUMP_P_CODE \
1180
  length = 2; \
1181
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
1182
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
1183
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
1184
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
1185
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
1186
 
1187
#define EXTRACT_IFMT_BAS_C_VARS \
1188
  SI f_indir_pc__dword_pcrel; \
1189
  UINT f_operand2; \
1190
  UINT f_mode; \
1191
  UINT f_opcode; \
1192
  UINT f_size; \
1193
  UINT f_operand1; \
1194
  /* Contents of trailing part of insn.  */ \
1195
  UINT word_1; \
1196
  unsigned int length;
1197
#define EXTRACT_IFMT_BAS_C_CODE \
1198
  length = 6; \
1199
  word_1 = GETIMEMUSI (current_cpu, pc + 2); \
1200
  f_indir_pc__dword_pcrel = ((pc) + ((0|(EXTRACT_LSB0_UINT (word_1, 32, 31, 32) << 0)))); \
1201
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
1202
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
1203
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
1204
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
1205
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
1206
 
1207
#define EXTRACT_IFMT_BREAK_VARS \
1208
  UINT f_operand2; \
1209
  UINT f_mode; \
1210
  UINT f_opcode; \
1211
  UINT f_size; \
1212
  UINT f_u4; \
1213
  unsigned int length;
1214
#define EXTRACT_IFMT_BREAK_CODE \
1215
  length = 2; \
1216
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
1217
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
1218
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
1219
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
1220
  f_u4 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
1221
 
1222
#define EXTRACT_IFMT_SCC_VARS \
1223
  UINT f_operand2; \
1224
  UINT f_mode; \
1225
  UINT f_opcode; \
1226
  UINT f_size; \
1227
  UINT f_operand1; \
1228
  unsigned int length;
1229
#define EXTRACT_IFMT_SCC_CODE \
1230
  length = 2; \
1231
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
1232
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
1233
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
1234
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
1235
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
1236
 
1237
#define EXTRACT_IFMT_ADDOQ_VARS \
1238
  UINT f_operand2; \
1239
  UINT f_mode; \
1240
  UINT f_opcode_hi; \
1241
  INT f_s8; \
1242
  unsigned int length;
1243
#define EXTRACT_IFMT_ADDOQ_CODE \
1244
  length = 2; \
1245
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
1246
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
1247
  f_opcode_hi = EXTRACT_LSB0_UINT (insn, 16, 9, 2); \
1248
  f_s8 = EXTRACT_LSB0_INT (insn, 16, 7, 8); \
1249
 
1250
#define EXTRACT_IFMT_FIDXI_VARS \
1251
  UINT f_operand2; \
1252
  UINT f_mode; \
1253
  UINT f_opcode; \
1254
  UINT f_size; \
1255
  UINT f_operand1; \
1256
  unsigned int length;
1257
#define EXTRACT_IFMT_FIDXI_CODE \
1258
  length = 2; \
1259
  f_operand2 = EXTRACT_LSB0_UINT (insn, 16, 15, 4); \
1260
  f_mode = EXTRACT_LSB0_UINT (insn, 16, 11, 2); \
1261
  f_opcode = EXTRACT_LSB0_UINT (insn, 16, 9, 4); \
1262
  f_size = EXTRACT_LSB0_UINT (insn, 16, 5, 2); \
1263
  f_operand1 = EXTRACT_LSB0_UINT (insn, 16, 3, 4); \
1264
 
1265
/* Collection of various things for the trace handler to use.  */
1266
 
1267
typedef struct trace_record {
1268
  IADDR pc;
1269
  /* FIXME:wip */
1270
} TRACE_RECORD;
1271
 
1272
#endif /* CPU_CRISV32F_H */

powered by: WebSVN 2.1.0

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