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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [sim/] [iq2000/] [decode.c] - Blame information for rev 840

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Simulator instruction decoder for iq2000bf.
2
 
3
THIS FILE IS MACHINE GENERATED WITH CGEN.
4
 
5
Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
6
 
7
This file is part of the GNU simulators.
8
 
9
This program 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 of the License, or
12
(at your option) any later version.
13
 
14
This program is distributed in the hope that it will be useful,
15
but WITHOUT ANY WARRANTY; without even the implied warranty of
16
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
GNU General Public License for more details.
18
 
19
You should have received a copy of the GNU General Public License
20
along with this program.  If not, see <http://www.gnu.org/licenses/>.
21
 
22
*/
23
 
24
#define WANT_CPU iq2000bf
25
#define WANT_CPU_IQ2000BF
26
 
27
#include "sim-main.h"
28
#include "sim-assert.h"
29
 
30
/* The instruction descriptor array.
31
   This is computed at runtime.  Space for it is not malloc'd to save a
32
   teensy bit of cpu in the decoder.  Moving it to malloc space is trivial
33
   but won't be done until necessary (we don't currently support the runtime
34
   addition of instructions nor an SMP machine with different cpus).  */
35
static IDESC iq2000bf_insn_data[IQ2000BF_INSN_BMB + 1];
36
 
37
/* Commas between elements are contained in the macros.
38
   Some of these are conditionally compiled out.  */
39
 
40
static const struct insn_sem iq2000bf_insn_sem[] =
41
{
42
  { VIRTUAL_INSN_X_INVALID, IQ2000BF_INSN_X_INVALID, IQ2000BF_SFMT_EMPTY },
43
  { VIRTUAL_INSN_X_AFTER, IQ2000BF_INSN_X_AFTER, IQ2000BF_SFMT_EMPTY },
44
  { VIRTUAL_INSN_X_BEFORE, IQ2000BF_INSN_X_BEFORE, IQ2000BF_SFMT_EMPTY },
45
  { VIRTUAL_INSN_X_CTI_CHAIN, IQ2000BF_INSN_X_CTI_CHAIN, IQ2000BF_SFMT_EMPTY },
46
  { VIRTUAL_INSN_X_CHAIN, IQ2000BF_INSN_X_CHAIN, IQ2000BF_SFMT_EMPTY },
47
  { VIRTUAL_INSN_X_BEGIN, IQ2000BF_INSN_X_BEGIN, IQ2000BF_SFMT_EMPTY },
48
  { IQ2000_INSN_ADD, IQ2000BF_INSN_ADD, IQ2000BF_SFMT_ADD },
49
  { IQ2000_INSN_ADDI, IQ2000BF_INSN_ADDI, IQ2000BF_SFMT_ADDI },
50
  { IQ2000_INSN_ADDIU, IQ2000BF_INSN_ADDIU, IQ2000BF_SFMT_ADDI },
51
  { IQ2000_INSN_ADDU, IQ2000BF_INSN_ADDU, IQ2000BF_SFMT_ADD },
52
  { IQ2000_INSN_ADO16, IQ2000BF_INSN_ADO16, IQ2000BF_SFMT_ADO16 },
53
  { IQ2000_INSN_AND, IQ2000BF_INSN_AND, IQ2000BF_SFMT_ADD },
54
  { IQ2000_INSN_ANDI, IQ2000BF_INSN_ANDI, IQ2000BF_SFMT_ADDI },
55
  { IQ2000_INSN_ANDOI, IQ2000BF_INSN_ANDOI, IQ2000BF_SFMT_ADDI },
56
  { IQ2000_INSN_NOR, IQ2000BF_INSN_NOR, IQ2000BF_SFMT_ADD },
57
  { IQ2000_INSN_OR, IQ2000BF_INSN_OR, IQ2000BF_SFMT_ADD },
58
  { IQ2000_INSN_ORI, IQ2000BF_INSN_ORI, IQ2000BF_SFMT_ADDI },
59
  { IQ2000_INSN_RAM, IQ2000BF_INSN_RAM, IQ2000BF_SFMT_RAM },
60
  { IQ2000_INSN_SLL, IQ2000BF_INSN_SLL, IQ2000BF_SFMT_SLL },
61
  { IQ2000_INSN_SLLV, IQ2000BF_INSN_SLLV, IQ2000BF_SFMT_ADD },
62
  { IQ2000_INSN_SLMV, IQ2000BF_INSN_SLMV, IQ2000BF_SFMT_SLMV },
63
  { IQ2000_INSN_SLT, IQ2000BF_INSN_SLT, IQ2000BF_SFMT_SLT },
64
  { IQ2000_INSN_SLTI, IQ2000BF_INSN_SLTI, IQ2000BF_SFMT_SLTI },
65
  { IQ2000_INSN_SLTIU, IQ2000BF_INSN_SLTIU, IQ2000BF_SFMT_SLTI },
66
  { IQ2000_INSN_SLTU, IQ2000BF_INSN_SLTU, IQ2000BF_SFMT_SLT },
67
  { IQ2000_INSN_SRA, IQ2000BF_INSN_SRA, IQ2000BF_SFMT_SLL },
68
  { IQ2000_INSN_SRAV, IQ2000BF_INSN_SRAV, IQ2000BF_SFMT_ADD },
69
  { IQ2000_INSN_SRL, IQ2000BF_INSN_SRL, IQ2000BF_SFMT_SLL },
70
  { IQ2000_INSN_SRLV, IQ2000BF_INSN_SRLV, IQ2000BF_SFMT_ADD },
71
  { IQ2000_INSN_SRMV, IQ2000BF_INSN_SRMV, IQ2000BF_SFMT_SLMV },
72
  { IQ2000_INSN_SUB, IQ2000BF_INSN_SUB, IQ2000BF_SFMT_ADD },
73
  { IQ2000_INSN_SUBU, IQ2000BF_INSN_SUBU, IQ2000BF_SFMT_ADD },
74
  { IQ2000_INSN_XOR, IQ2000BF_INSN_XOR, IQ2000BF_SFMT_ADD },
75
  { IQ2000_INSN_XORI, IQ2000BF_INSN_XORI, IQ2000BF_SFMT_ADDI },
76
  { IQ2000_INSN_BBI, IQ2000BF_INSN_BBI, IQ2000BF_SFMT_BBI },
77
  { IQ2000_INSN_BBIN, IQ2000BF_INSN_BBIN, IQ2000BF_SFMT_BBI },
78
  { IQ2000_INSN_BBV, IQ2000BF_INSN_BBV, IQ2000BF_SFMT_BBV },
79
  { IQ2000_INSN_BBVN, IQ2000BF_INSN_BBVN, IQ2000BF_SFMT_BBV },
80
  { IQ2000_INSN_BEQ, IQ2000BF_INSN_BEQ, IQ2000BF_SFMT_BBV },
81
  { IQ2000_INSN_BEQL, IQ2000BF_INSN_BEQL, IQ2000BF_SFMT_BBV },
82
  { IQ2000_INSN_BGEZ, IQ2000BF_INSN_BGEZ, IQ2000BF_SFMT_BGEZ },
83
  { IQ2000_INSN_BGEZAL, IQ2000BF_INSN_BGEZAL, IQ2000BF_SFMT_BGEZAL },
84
  { IQ2000_INSN_BGEZALL, IQ2000BF_INSN_BGEZALL, IQ2000BF_SFMT_BGEZAL },
85
  { IQ2000_INSN_BGEZL, IQ2000BF_INSN_BGEZL, IQ2000BF_SFMT_BGEZ },
86
  { IQ2000_INSN_BLTZ, IQ2000BF_INSN_BLTZ, IQ2000BF_SFMT_BGEZ },
87
  { IQ2000_INSN_BLTZL, IQ2000BF_INSN_BLTZL, IQ2000BF_SFMT_BGEZ },
88
  { IQ2000_INSN_BLTZAL, IQ2000BF_INSN_BLTZAL, IQ2000BF_SFMT_BGEZAL },
89
  { IQ2000_INSN_BLTZALL, IQ2000BF_INSN_BLTZALL, IQ2000BF_SFMT_BGEZAL },
90
  { IQ2000_INSN_BMB0, IQ2000BF_INSN_BMB0, IQ2000BF_SFMT_BBV },
91
  { IQ2000_INSN_BMB1, IQ2000BF_INSN_BMB1, IQ2000BF_SFMT_BBV },
92
  { IQ2000_INSN_BMB2, IQ2000BF_INSN_BMB2, IQ2000BF_SFMT_BBV },
93
  { IQ2000_INSN_BMB3, IQ2000BF_INSN_BMB3, IQ2000BF_SFMT_BBV },
94
  { IQ2000_INSN_BNE, IQ2000BF_INSN_BNE, IQ2000BF_SFMT_BBV },
95
  { IQ2000_INSN_BNEL, IQ2000BF_INSN_BNEL, IQ2000BF_SFMT_BBV },
96
  { IQ2000_INSN_JALR, IQ2000BF_INSN_JALR, IQ2000BF_SFMT_JALR },
97
  { IQ2000_INSN_JR, IQ2000BF_INSN_JR, IQ2000BF_SFMT_JR },
98
  { IQ2000_INSN_LB, IQ2000BF_INSN_LB, IQ2000BF_SFMT_LB },
99
  { IQ2000_INSN_LBU, IQ2000BF_INSN_LBU, IQ2000BF_SFMT_LB },
100
  { IQ2000_INSN_LH, IQ2000BF_INSN_LH, IQ2000BF_SFMT_LH },
101
  { IQ2000_INSN_LHU, IQ2000BF_INSN_LHU, IQ2000BF_SFMT_LH },
102
  { IQ2000_INSN_LUI, IQ2000BF_INSN_LUI, IQ2000BF_SFMT_LUI },
103
  { IQ2000_INSN_LW, IQ2000BF_INSN_LW, IQ2000BF_SFMT_LW },
104
  { IQ2000_INSN_SB, IQ2000BF_INSN_SB, IQ2000BF_SFMT_SB },
105
  { IQ2000_INSN_SH, IQ2000BF_INSN_SH, IQ2000BF_SFMT_SH },
106
  { IQ2000_INSN_SW, IQ2000BF_INSN_SW, IQ2000BF_SFMT_SW },
107
  { IQ2000_INSN_BREAK, IQ2000BF_INSN_BREAK, IQ2000BF_SFMT_BREAK },
108
  { IQ2000_INSN_SYSCALL, IQ2000BF_INSN_SYSCALL, IQ2000BF_SFMT_SYSCALL },
109
  { IQ2000_INSN_ANDOUI, IQ2000BF_INSN_ANDOUI, IQ2000BF_SFMT_ANDOUI },
110
  { IQ2000_INSN_ORUI, IQ2000BF_INSN_ORUI, IQ2000BF_SFMT_ANDOUI },
111
  { IQ2000_INSN_BGTZ, IQ2000BF_INSN_BGTZ, IQ2000BF_SFMT_BGEZ },
112
  { IQ2000_INSN_BGTZL, IQ2000BF_INSN_BGTZL, IQ2000BF_SFMT_BGEZ },
113
  { IQ2000_INSN_BLEZ, IQ2000BF_INSN_BLEZ, IQ2000BF_SFMT_BGEZ },
114
  { IQ2000_INSN_BLEZL, IQ2000BF_INSN_BLEZL, IQ2000BF_SFMT_BGEZ },
115
  { IQ2000_INSN_MRGB, IQ2000BF_INSN_MRGB, IQ2000BF_SFMT_MRGB },
116
  { IQ2000_INSN_BCTXT, IQ2000BF_INSN_BCTXT, IQ2000BF_SFMT_BCTXT },
117
  { IQ2000_INSN_BC0F, IQ2000BF_INSN_BC0F, IQ2000BF_SFMT_BCTXT },
118
  { IQ2000_INSN_BC0FL, IQ2000BF_INSN_BC0FL, IQ2000BF_SFMT_BCTXT },
119
  { IQ2000_INSN_BC3F, IQ2000BF_INSN_BC3F, IQ2000BF_SFMT_BCTXT },
120
  { IQ2000_INSN_BC3FL, IQ2000BF_INSN_BC3FL, IQ2000BF_SFMT_BCTXT },
121
  { IQ2000_INSN_BC0T, IQ2000BF_INSN_BC0T, IQ2000BF_SFMT_BCTXT },
122
  { IQ2000_INSN_BC0TL, IQ2000BF_INSN_BC0TL, IQ2000BF_SFMT_BCTXT },
123
  { IQ2000_INSN_BC3T, IQ2000BF_INSN_BC3T, IQ2000BF_SFMT_BCTXT },
124
  { IQ2000_INSN_BC3TL, IQ2000BF_INSN_BC3TL, IQ2000BF_SFMT_BCTXT },
125
  { IQ2000_INSN_CFC0, IQ2000BF_INSN_CFC0, IQ2000BF_SFMT_SYSCALL },
126
  { IQ2000_INSN_CFC1, IQ2000BF_INSN_CFC1, IQ2000BF_SFMT_SYSCALL },
127
  { IQ2000_INSN_CFC2, IQ2000BF_INSN_CFC2, IQ2000BF_SFMT_SYSCALL },
128
  { IQ2000_INSN_CFC3, IQ2000BF_INSN_CFC3, IQ2000BF_SFMT_SYSCALL },
129
  { IQ2000_INSN_CHKHDR, IQ2000BF_INSN_CHKHDR, IQ2000BF_SFMT_SYSCALL },
130
  { IQ2000_INSN_CTC0, IQ2000BF_INSN_CTC0, IQ2000BF_SFMT_SYSCALL },
131
  { IQ2000_INSN_CTC1, IQ2000BF_INSN_CTC1, IQ2000BF_SFMT_SYSCALL },
132
  { IQ2000_INSN_CTC2, IQ2000BF_INSN_CTC2, IQ2000BF_SFMT_SYSCALL },
133
  { IQ2000_INSN_CTC3, IQ2000BF_INSN_CTC3, IQ2000BF_SFMT_SYSCALL },
134
  { IQ2000_INSN_JCR, IQ2000BF_INSN_JCR, IQ2000BF_SFMT_BCTXT },
135
  { IQ2000_INSN_LUC32, IQ2000BF_INSN_LUC32, IQ2000BF_SFMT_SYSCALL },
136
  { IQ2000_INSN_LUC32L, IQ2000BF_INSN_LUC32L, IQ2000BF_SFMT_SYSCALL },
137
  { IQ2000_INSN_LUC64, IQ2000BF_INSN_LUC64, IQ2000BF_SFMT_SYSCALL },
138
  { IQ2000_INSN_LUC64L, IQ2000BF_INSN_LUC64L, IQ2000BF_SFMT_SYSCALL },
139
  { IQ2000_INSN_LUK, IQ2000BF_INSN_LUK, IQ2000BF_SFMT_SYSCALL },
140
  { IQ2000_INSN_LULCK, IQ2000BF_INSN_LULCK, IQ2000BF_SFMT_SYSCALL },
141
  { IQ2000_INSN_LUM32, IQ2000BF_INSN_LUM32, IQ2000BF_SFMT_SYSCALL },
142
  { IQ2000_INSN_LUM32L, IQ2000BF_INSN_LUM32L, IQ2000BF_SFMT_SYSCALL },
143
  { IQ2000_INSN_LUM64, IQ2000BF_INSN_LUM64, IQ2000BF_SFMT_SYSCALL },
144
  { IQ2000_INSN_LUM64L, IQ2000BF_INSN_LUM64L, IQ2000BF_SFMT_SYSCALL },
145
  { IQ2000_INSN_LUR, IQ2000BF_INSN_LUR, IQ2000BF_SFMT_SYSCALL },
146
  { IQ2000_INSN_LURL, IQ2000BF_INSN_LURL, IQ2000BF_SFMT_SYSCALL },
147
  { IQ2000_INSN_LUULCK, IQ2000BF_INSN_LUULCK, IQ2000BF_SFMT_SYSCALL },
148
  { IQ2000_INSN_MFC0, IQ2000BF_INSN_MFC0, IQ2000BF_SFMT_SYSCALL },
149
  { IQ2000_INSN_MFC1, IQ2000BF_INSN_MFC1, IQ2000BF_SFMT_SYSCALL },
150
  { IQ2000_INSN_MFC2, IQ2000BF_INSN_MFC2, IQ2000BF_SFMT_SYSCALL },
151
  { IQ2000_INSN_MFC3, IQ2000BF_INSN_MFC3, IQ2000BF_SFMT_SYSCALL },
152
  { IQ2000_INSN_MTC0, IQ2000BF_INSN_MTC0, IQ2000BF_SFMT_SYSCALL },
153
  { IQ2000_INSN_MTC1, IQ2000BF_INSN_MTC1, IQ2000BF_SFMT_SYSCALL },
154
  { IQ2000_INSN_MTC2, IQ2000BF_INSN_MTC2, IQ2000BF_SFMT_SYSCALL },
155
  { IQ2000_INSN_MTC3, IQ2000BF_INSN_MTC3, IQ2000BF_SFMT_SYSCALL },
156
  { IQ2000_INSN_PKRL, IQ2000BF_INSN_PKRL, IQ2000BF_SFMT_SYSCALL },
157
  { IQ2000_INSN_PKRLR1, IQ2000BF_INSN_PKRLR1, IQ2000BF_SFMT_SYSCALL },
158
  { IQ2000_INSN_PKRLR30, IQ2000BF_INSN_PKRLR30, IQ2000BF_SFMT_SYSCALL },
159
  { IQ2000_INSN_RB, IQ2000BF_INSN_RB, IQ2000BF_SFMT_SYSCALL },
160
  { IQ2000_INSN_RBR1, IQ2000BF_INSN_RBR1, IQ2000BF_SFMT_SYSCALL },
161
  { IQ2000_INSN_RBR30, IQ2000BF_INSN_RBR30, IQ2000BF_SFMT_SYSCALL },
162
  { IQ2000_INSN_RFE, IQ2000BF_INSN_RFE, IQ2000BF_SFMT_SYSCALL },
163
  { IQ2000_INSN_RX, IQ2000BF_INSN_RX, IQ2000BF_SFMT_SYSCALL },
164
  { IQ2000_INSN_RXR1, IQ2000BF_INSN_RXR1, IQ2000BF_SFMT_SYSCALL },
165
  { IQ2000_INSN_RXR30, IQ2000BF_INSN_RXR30, IQ2000BF_SFMT_SYSCALL },
166
  { IQ2000_INSN_SLEEP, IQ2000BF_INSN_SLEEP, IQ2000BF_SFMT_SYSCALL },
167
  { IQ2000_INSN_SRRD, IQ2000BF_INSN_SRRD, IQ2000BF_SFMT_SYSCALL },
168
  { IQ2000_INSN_SRRDL, IQ2000BF_INSN_SRRDL, IQ2000BF_SFMT_SYSCALL },
169
  { IQ2000_INSN_SRULCK, IQ2000BF_INSN_SRULCK, IQ2000BF_SFMT_SYSCALL },
170
  { IQ2000_INSN_SRWR, IQ2000BF_INSN_SRWR, IQ2000BF_SFMT_SYSCALL },
171
  { IQ2000_INSN_SRWRU, IQ2000BF_INSN_SRWRU, IQ2000BF_SFMT_SYSCALL },
172
  { IQ2000_INSN_TRAPQFL, IQ2000BF_INSN_TRAPQFL, IQ2000BF_SFMT_SYSCALL },
173
  { IQ2000_INSN_TRAPQNE, IQ2000BF_INSN_TRAPQNE, IQ2000BF_SFMT_SYSCALL },
174
  { IQ2000_INSN_TRAPREL, IQ2000BF_INSN_TRAPREL, IQ2000BF_SFMT_SYSCALL },
175
  { IQ2000_INSN_WB, IQ2000BF_INSN_WB, IQ2000BF_SFMT_SYSCALL },
176
  { IQ2000_INSN_WBU, IQ2000BF_INSN_WBU, IQ2000BF_SFMT_SYSCALL },
177
  { IQ2000_INSN_WBR1, IQ2000BF_INSN_WBR1, IQ2000BF_SFMT_SYSCALL },
178
  { IQ2000_INSN_WBR1U, IQ2000BF_INSN_WBR1U, IQ2000BF_SFMT_SYSCALL },
179
  { IQ2000_INSN_WBR30, IQ2000BF_INSN_WBR30, IQ2000BF_SFMT_SYSCALL },
180
  { IQ2000_INSN_WBR30U, IQ2000BF_INSN_WBR30U, IQ2000BF_SFMT_SYSCALL },
181
  { IQ2000_INSN_WX, IQ2000BF_INSN_WX, IQ2000BF_SFMT_SYSCALL },
182
  { IQ2000_INSN_WXU, IQ2000BF_INSN_WXU, IQ2000BF_SFMT_SYSCALL },
183
  { IQ2000_INSN_WXR1, IQ2000BF_INSN_WXR1, IQ2000BF_SFMT_SYSCALL },
184
  { IQ2000_INSN_WXR1U, IQ2000BF_INSN_WXR1U, IQ2000BF_SFMT_SYSCALL },
185
  { IQ2000_INSN_WXR30, IQ2000BF_INSN_WXR30, IQ2000BF_SFMT_SYSCALL },
186
  { IQ2000_INSN_WXR30U, IQ2000BF_INSN_WXR30U, IQ2000BF_SFMT_SYSCALL },
187
  { IQ2000_INSN_LDW, IQ2000BF_INSN_LDW, IQ2000BF_SFMT_LDW },
188
  { IQ2000_INSN_SDW, IQ2000BF_INSN_SDW, IQ2000BF_SFMT_SDW },
189
  { IQ2000_INSN_J, IQ2000BF_INSN_J, IQ2000BF_SFMT_J },
190
  { IQ2000_INSN_JAL, IQ2000BF_INSN_JAL, IQ2000BF_SFMT_JAL },
191
  { IQ2000_INSN_BMB, IQ2000BF_INSN_BMB, IQ2000BF_SFMT_BBV },
192
};
193
 
194
static const struct insn_sem iq2000bf_insn_sem_invalid = {
195
  VIRTUAL_INSN_X_INVALID, IQ2000BF_INSN_X_INVALID, IQ2000BF_SFMT_EMPTY
196
};
197
 
198
/* Initialize an IDESC from the compile-time computable parts.  */
199
 
200
static INLINE void
201
init_idesc (SIM_CPU *cpu, IDESC *id, const struct insn_sem *t)
202
{
203
  const CGEN_INSN *insn_table = CGEN_CPU_INSN_TABLE (CPU_CPU_DESC (cpu))->init_entries;
204
 
205
  id->num = t->index;
206
  id->sfmt = t->sfmt;
207
  if ((int) t->type <= 0)
208
    id->idata = & cgen_virtual_insn_table[- (int) t->type];
209
  else
210
    id->idata = & insn_table[t->type];
211
  id->attrs = CGEN_INSN_ATTRS (id->idata);
212
  /* Oh my god, a magic number.  */
213
  id->length = CGEN_INSN_BITSIZE (id->idata) / 8;
214
 
215
#if WITH_PROFILE_MODEL_P
216
  id->timing = & MODEL_TIMING (CPU_MODEL (cpu)) [t->index];
217
  {
218
    SIM_DESC sd = CPU_STATE (cpu);
219
    SIM_ASSERT (t->index == id->timing->num);
220
  }
221
#endif
222
 
223
  /* Semantic pointers are initialized elsewhere.  */
224
}
225
 
226
/* Initialize the instruction descriptor table.  */
227
 
228
void
229
iq2000bf_init_idesc_table (SIM_CPU *cpu)
230
{
231
  IDESC *id,*tabend;
232
  const struct insn_sem *t,*tend;
233
  int tabsize = sizeof (iq2000bf_insn_data) / sizeof (IDESC);
234
  IDESC *table = iq2000bf_insn_data;
235
 
236
  memset (table, 0, tabsize * sizeof (IDESC));
237
 
238
  /* First set all entries to the `invalid insn'.  */
239
  t = & iq2000bf_insn_sem_invalid;
240
  for (id = table, tabend = table + tabsize; id < tabend; ++id)
241
    init_idesc (cpu, id, t);
242
 
243
  /* Now fill in the values for the chosen cpu.  */
244
  for (t = iq2000bf_insn_sem, tend = t + sizeof (iq2000bf_insn_sem) / sizeof (*t);
245
       t != tend; ++t)
246
    {
247
      init_idesc (cpu, & table[t->index], t);
248
    }
249
 
250
  /* Link the IDESC table into the cpu.  */
251
  CPU_IDESC (cpu) = table;
252
}
253
 
254
/* Given an instruction, return a pointer to its IDESC entry.  */
255
 
256
const IDESC *
257
iq2000bf_decode (SIM_CPU *current_cpu, IADDR pc,
258
              CGEN_INSN_INT base_insn, CGEN_INSN_INT entire_insn,
259
              ARGBUF *abuf)
260
{
261
  /* Result of decoder.  */
262
  IQ2000BF_INSN_TYPE itype;
263
 
264
  {
265
    CGEN_INSN_INT insn = base_insn;
266
 
267
    {
268
      unsigned int val = (((insn >> 26) & (63 << 0)));
269
      switch (val)
270
      {
271
      case 0 :
272
        {
273
          unsigned int val = (((insn >> 1) & (1 << 4)) | ((insn >> 0) & (15 << 0)));
274
          switch (val)
275
          {
276
          case 0 : itype = IQ2000BF_INSN_SLL;goto extract_sfmt_sll;
277
          case 1 : itype = IQ2000BF_INSN_SLMV;goto extract_sfmt_slmv;
278
          case 2 : itype = IQ2000BF_INSN_SRL;goto extract_sfmt_sll;
279
          case 3 : itype = IQ2000BF_INSN_SRA;goto extract_sfmt_sll;
280
          case 4 : itype = IQ2000BF_INSN_SLLV;goto extract_sfmt_add;
281
          case 5 : itype = IQ2000BF_INSN_SRMV;goto extract_sfmt_slmv;
282
          case 6 : itype = IQ2000BF_INSN_SRLV;goto extract_sfmt_add;
283
          case 7 : itype = IQ2000BF_INSN_SRAV;goto extract_sfmt_add;
284
          case 8 : itype = IQ2000BF_INSN_JR;goto extract_sfmt_jr;
285
          case 9 : itype = IQ2000BF_INSN_JALR;goto extract_sfmt_jalr;
286
          case 10 : itype = IQ2000BF_INSN_JCR;goto extract_sfmt_bctxt;
287
          case 12 : itype = IQ2000BF_INSN_SYSCALL;goto extract_sfmt_syscall;
288
          case 13 : itype = IQ2000BF_INSN_BREAK;goto extract_sfmt_break;
289
          case 14 : itype = IQ2000BF_INSN_SLEEP;goto extract_sfmt_syscall;
290
          case 16 : itype = IQ2000BF_INSN_ADD;goto extract_sfmt_add;
291
          case 17 : itype = IQ2000BF_INSN_ADDU;goto extract_sfmt_add;
292
          case 18 : itype = IQ2000BF_INSN_SUB;goto extract_sfmt_add;
293
          case 19 : itype = IQ2000BF_INSN_SUBU;goto extract_sfmt_add;
294
          case 20 : itype = IQ2000BF_INSN_AND;goto extract_sfmt_add;
295
          case 21 : itype = IQ2000BF_INSN_OR;goto extract_sfmt_add;
296
          case 22 : itype = IQ2000BF_INSN_XOR;goto extract_sfmt_add;
297
          case 23 : itype = IQ2000BF_INSN_NOR;goto extract_sfmt_add;
298
          case 25 : itype = IQ2000BF_INSN_ADO16;goto extract_sfmt_ado16;
299
          case 26 : itype = IQ2000BF_INSN_SLT;goto extract_sfmt_slt;
300
          case 27 : itype = IQ2000BF_INSN_SLTU;goto extract_sfmt_slt;
301
          case 29 : itype = IQ2000BF_INSN_MRGB;goto extract_sfmt_mrgb;
302
          default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
303
          }
304
        }
305
      case 1 :
306
        {
307
          unsigned int val = (((insn >> 17) & (1 << 3)) | ((insn >> 16) & (7 << 0)));
308
          switch (val)
309
          {
310
          case 0 : itype = IQ2000BF_INSN_BLTZ;goto extract_sfmt_bgez;
311
          case 1 : itype = IQ2000BF_INSN_BGEZ;goto extract_sfmt_bgez;
312
          case 2 : itype = IQ2000BF_INSN_BLTZL;goto extract_sfmt_bgez;
313
          case 3 : itype = IQ2000BF_INSN_BGEZL;goto extract_sfmt_bgez;
314
          case 6 : itype = IQ2000BF_INSN_BCTXT;goto extract_sfmt_bctxt;
315
          case 8 : itype = IQ2000BF_INSN_BLTZAL;goto extract_sfmt_bgezal;
316
          case 9 : itype = IQ2000BF_INSN_BGEZAL;goto extract_sfmt_bgezal;
317
          case 10 : itype = IQ2000BF_INSN_BLTZALL;goto extract_sfmt_bgezal;
318
          case 11 : itype = IQ2000BF_INSN_BGEZALL;goto extract_sfmt_bgezal;
319
          default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
320
          }
321
        }
322
      case 2 : itype = IQ2000BF_INSN_J;goto extract_sfmt_j;
323
      case 3 : itype = IQ2000BF_INSN_JAL;goto extract_sfmt_jal;
324
      case 4 : itype = IQ2000BF_INSN_BEQ;goto extract_sfmt_bbv;
325
      case 5 : itype = IQ2000BF_INSN_BNE;goto extract_sfmt_bbv;
326
      case 6 : itype = IQ2000BF_INSN_BLEZ;goto extract_sfmt_bgez;
327
      case 7 : itype = IQ2000BF_INSN_BGTZ;goto extract_sfmt_bgez;
328
      case 8 : itype = IQ2000BF_INSN_ADDI;goto extract_sfmt_addi;
329
      case 9 : itype = IQ2000BF_INSN_ADDIU;goto extract_sfmt_addi;
330
      case 10 : itype = IQ2000BF_INSN_SLTI;goto extract_sfmt_slti;
331
      case 11 : itype = IQ2000BF_INSN_SLTIU;goto extract_sfmt_slti;
332
      case 12 : itype = IQ2000BF_INSN_ANDI;goto extract_sfmt_addi;
333
      case 13 : itype = IQ2000BF_INSN_ORI;goto extract_sfmt_addi;
334
      case 14 : itype = IQ2000BF_INSN_XORI;goto extract_sfmt_addi;
335
      case 15 : itype = IQ2000BF_INSN_LUI;goto extract_sfmt_lui;
336
      case 16 :
337
        {
338
          unsigned int val = (((insn >> 19) & (15 << 3)) | ((insn >> 15) & (3 << 1)) | ((insn >> 4) & (1 << 0)));
339
          switch (val)
340
          {
341
          case 0 : /* fall through */
342
          case 2 : /* fall through */
343
          case 4 : /* fall through */
344
          case 6 : itype = IQ2000BF_INSN_MFC0;goto extract_sfmt_syscall;
345
          case 8 : /* fall through */
346
          case 10 : /* fall through */
347
          case 12 : /* fall through */
348
          case 14 : itype = IQ2000BF_INSN_CFC0;goto extract_sfmt_syscall;
349
          case 16 : /* fall through */
350
          case 18 : /* fall through */
351
          case 20 : /* fall through */
352
          case 22 : itype = IQ2000BF_INSN_MTC0;goto extract_sfmt_syscall;
353
          case 24 : /* fall through */
354
          case 26 : /* fall through */
355
          case 28 : /* fall through */
356
          case 30 : itype = IQ2000BF_INSN_CTC0;goto extract_sfmt_syscall;
357
          case 32 : /* fall through */
358
          case 33 : itype = IQ2000BF_INSN_BC0F;goto extract_sfmt_bctxt;
359
          case 34 : /* fall through */
360
          case 35 : itype = IQ2000BF_INSN_BC0T;goto extract_sfmt_bctxt;
361
          case 36 : /* fall through */
362
          case 37 : itype = IQ2000BF_INSN_BC0FL;goto extract_sfmt_bctxt;
363
          case 38 : /* fall through */
364
          case 39 : itype = IQ2000BF_INSN_BC0TL;goto extract_sfmt_bctxt;
365
          case 65 : itype = IQ2000BF_INSN_RFE;goto extract_sfmt_syscall;
366
          default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
367
          }
368
        }
369
      case 17 :
370
        {
371
          unsigned int val = (((insn >> 22) & (3 << 0)));
372
          switch (val)
373
          {
374
          case 0 : itype = IQ2000BF_INSN_MFC1;goto extract_sfmt_syscall;
375
          case 1 : itype = IQ2000BF_INSN_CFC1;goto extract_sfmt_syscall;
376
          case 2 : itype = IQ2000BF_INSN_MTC1;goto extract_sfmt_syscall;
377
          case 3 : itype = IQ2000BF_INSN_CTC1;goto extract_sfmt_syscall;
378
          default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
379
          }
380
        }
381
      case 18 :
382
        {
383
          unsigned int val = (((insn >> 16) & (3 << 5)) | ((insn >> 0) & (31 << 0)));
384
          switch (val)
385
          {
386
          case 0 :
387
            {
388
              unsigned int val = (((insn >> 23) & (1 << 0)));
389
              switch (val)
390
              {
391
              case 0 : itype = IQ2000BF_INSN_MFC2;goto extract_sfmt_syscall;
392
              case 1 : itype = IQ2000BF_INSN_MTC2;goto extract_sfmt_syscall;
393
              default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
394
              }
395
            }
396
          case 32 : itype = IQ2000BF_INSN_LUULCK;goto extract_sfmt_syscall;
397
          case 33 : itype = IQ2000BF_INSN_LUR;goto extract_sfmt_syscall;
398
          case 34 : itype = IQ2000BF_INSN_LUM32;goto extract_sfmt_syscall;
399
          case 35 : itype = IQ2000BF_INSN_LUC32;goto extract_sfmt_syscall;
400
          case 36 : itype = IQ2000BF_INSN_LULCK;goto extract_sfmt_syscall;
401
          case 37 : itype = IQ2000BF_INSN_LURL;goto extract_sfmt_syscall;
402
          case 38 : itype = IQ2000BF_INSN_LUM32L;goto extract_sfmt_syscall;
403
          case 39 : itype = IQ2000BF_INSN_LUC32L;goto extract_sfmt_syscall;
404
          case 40 : itype = IQ2000BF_INSN_LUK;goto extract_sfmt_syscall;
405
          case 42 : itype = IQ2000BF_INSN_LUM64;goto extract_sfmt_syscall;
406
          case 43 : itype = IQ2000BF_INSN_LUC64;goto extract_sfmt_syscall;
407
          case 46 : itype = IQ2000BF_INSN_LUM64L;goto extract_sfmt_syscall;
408
          case 47 : itype = IQ2000BF_INSN_LUC64L;goto extract_sfmt_syscall;
409
          case 48 : itype = IQ2000BF_INSN_SRRD;goto extract_sfmt_syscall;
410
          case 49 : itype = IQ2000BF_INSN_SRWR;goto extract_sfmt_syscall;
411
          case 52 : itype = IQ2000BF_INSN_SRRDL;goto extract_sfmt_syscall;
412
          case 53 : itype = IQ2000BF_INSN_SRWRU;goto extract_sfmt_syscall;
413
          case 54 : itype = IQ2000BF_INSN_SRULCK;goto extract_sfmt_syscall;
414
          case 64 :
415
            {
416
              unsigned int val = (((insn >> 23) & (1 << 0)));
417
              switch (val)
418
              {
419
              case 0 : itype = IQ2000BF_INSN_CFC2;goto extract_sfmt_syscall;
420
              case 1 : itype = IQ2000BF_INSN_CTC2;goto extract_sfmt_syscall;
421
              default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
422
              }
423
            }
424
          default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
425
          }
426
        }
427
      case 19 :
428
        {
429
          unsigned int val = (((insn >> 19) & (31 << 2)) | ((insn >> 0) & (3 << 0)));
430
          switch (val)
431
          {
432
          case 0 : itype = IQ2000BF_INSN_MFC3;goto extract_sfmt_syscall;
433
          case 4 :
434
            {
435
              unsigned int val = (((insn >> 2) & (3 << 0)));
436
              switch (val)
437
              {
438
              case 0 : itype = IQ2000BF_INSN_WB;goto extract_sfmt_syscall;
439
              case 1 : itype = IQ2000BF_INSN_RB;goto extract_sfmt_syscall;
440
              case 2 : itype = IQ2000BF_INSN_TRAPQFL;goto extract_sfmt_syscall;
441
              default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
442
              }
443
            }
444
          case 5 :
445
            {
446
              unsigned int val = (((insn >> 3) & (1 << 0)));
447
              switch (val)
448
              {
449
              case 0 : itype = IQ2000BF_INSN_WBU;goto extract_sfmt_syscall;
450
              case 1 : itype = IQ2000BF_INSN_TRAPQNE;goto extract_sfmt_syscall;
451
              default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
452
              }
453
            }
454
          case 6 :
455
            {
456
              unsigned int val = (((insn >> 2) & (3 << 0)));
457
              switch (val)
458
              {
459
              case 0 : itype = IQ2000BF_INSN_WX;goto extract_sfmt_syscall;
460
              case 1 : itype = IQ2000BF_INSN_RX;goto extract_sfmt_syscall;
461
              case 2 : itype = IQ2000BF_INSN_TRAPREL;goto extract_sfmt_syscall;
462
              default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
463
              }
464
            }
465
          case 7 :
466
            {
467
              unsigned int val = (((insn >> 2) & (1 << 0)));
468
              switch (val)
469
              {
470
              case 0 : itype = IQ2000BF_INSN_WXU;goto extract_sfmt_syscall;
471
              case 1 : itype = IQ2000BF_INSN_PKRL;goto extract_sfmt_syscall;
472
              default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
473
              }
474
            }
475
          case 8 : itype = IQ2000BF_INSN_CFC3;goto extract_sfmt_syscall;
476
          case 16 : itype = IQ2000BF_INSN_MTC3;goto extract_sfmt_syscall;
477
          case 24 : itype = IQ2000BF_INSN_CTC3;goto extract_sfmt_syscall;
478
          case 32 : /* fall through */
479
          case 33 : /* fall through */
480
          case 34 : /* fall through */
481
          case 35 :
482
            {
483
              unsigned int val = (((insn >> 16) & (3 << 0)));
484
              switch (val)
485
              {
486
              case 0 : itype = IQ2000BF_INSN_BC3F;goto extract_sfmt_bctxt;
487
              case 1 : itype = IQ2000BF_INSN_BC3T;goto extract_sfmt_bctxt;
488
              case 2 : itype = IQ2000BF_INSN_BC3FL;goto extract_sfmt_bctxt;
489
              case 3 : itype = IQ2000BF_INSN_BC3TL;goto extract_sfmt_bctxt;
490
              default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
491
              }
492
            }
493
          case 36 : itype = IQ2000BF_INSN_CHKHDR;goto extract_sfmt_syscall;
494
          case 64 : /* fall through */
495
          case 65 : /* fall through */
496
          case 66 : /* fall through */
497
          case 67 : itype = IQ2000BF_INSN_WBR1;goto extract_sfmt_syscall;
498
          case 68 : /* fall through */
499
          case 69 : /* fall through */
500
          case 70 : /* fall through */
501
          case 71 : itype = IQ2000BF_INSN_WBR1U;goto extract_sfmt_syscall;
502
          case 72 : /* fall through */
503
          case 73 : /* fall through */
504
          case 74 : /* fall through */
505
          case 75 : itype = IQ2000BF_INSN_WBR30;goto extract_sfmt_syscall;
506
          case 76 : /* fall through */
507
          case 77 : /* fall through */
508
          case 78 : /* fall through */
509
          case 79 : itype = IQ2000BF_INSN_WBR30U;goto extract_sfmt_syscall;
510
          case 80 : /* fall through */
511
          case 81 : /* fall through */
512
          case 82 : /* fall through */
513
          case 83 : itype = IQ2000BF_INSN_WXR1;goto extract_sfmt_syscall;
514
          case 84 : /* fall through */
515
          case 85 : /* fall through */
516
          case 86 : /* fall through */
517
          case 87 : itype = IQ2000BF_INSN_WXR1U;goto extract_sfmt_syscall;
518
          case 88 : /* fall through */
519
          case 89 : /* fall through */
520
          case 90 : /* fall through */
521
          case 91 : itype = IQ2000BF_INSN_WXR30;goto extract_sfmt_syscall;
522
          case 92 : /* fall through */
523
          case 93 : /* fall through */
524
          case 94 : /* fall through */
525
          case 95 : itype = IQ2000BF_INSN_WXR30U;goto extract_sfmt_syscall;
526
          case 96 : /* fall through */
527
          case 97 : /* fall through */
528
          case 98 : /* fall through */
529
          case 99 : itype = IQ2000BF_INSN_RBR1;goto extract_sfmt_syscall;
530
          case 104 : /* fall through */
531
          case 105 : /* fall through */
532
          case 106 : /* fall through */
533
          case 107 : itype = IQ2000BF_INSN_RBR30;goto extract_sfmt_syscall;
534
          case 112 : /* fall through */
535
          case 113 : /* fall through */
536
          case 114 : /* fall through */
537
          case 115 : itype = IQ2000BF_INSN_RXR1;goto extract_sfmt_syscall;
538
          case 116 : /* fall through */
539
          case 117 : /* fall through */
540
          case 118 : /* fall through */
541
          case 119 : itype = IQ2000BF_INSN_PKRLR1;goto extract_sfmt_syscall;
542
          case 120 : /* fall through */
543
          case 121 : /* fall through */
544
          case 122 : /* fall through */
545
          case 123 : itype = IQ2000BF_INSN_RXR30;goto extract_sfmt_syscall;
546
          case 124 : /* fall through */
547
          case 125 : /* fall through */
548
          case 126 : /* fall through */
549
          case 127 : itype = IQ2000BF_INSN_PKRLR30;goto extract_sfmt_syscall;
550
          default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
551
          }
552
        }
553
      case 20 : itype = IQ2000BF_INSN_BEQL;goto extract_sfmt_bbv;
554
      case 21 : itype = IQ2000BF_INSN_BNEL;goto extract_sfmt_bbv;
555
      case 22 : itype = IQ2000BF_INSN_BLEZL;goto extract_sfmt_bgez;
556
      case 23 : itype = IQ2000BF_INSN_BGTZL;goto extract_sfmt_bgez;
557
      case 24 : itype = IQ2000BF_INSN_BMB0;goto extract_sfmt_bbv;
558
      case 25 : itype = IQ2000BF_INSN_BMB1;goto extract_sfmt_bbv;
559
      case 26 : itype = IQ2000BF_INSN_BMB2;goto extract_sfmt_bbv;
560
      case 27 : itype = IQ2000BF_INSN_BMB3;goto extract_sfmt_bbv;
561
      case 28 : itype = IQ2000BF_INSN_BBI;goto extract_sfmt_bbi;
562
      case 29 : itype = IQ2000BF_INSN_BBV;goto extract_sfmt_bbv;
563
      case 30 : itype = IQ2000BF_INSN_BBIN;goto extract_sfmt_bbi;
564
      case 31 : itype = IQ2000BF_INSN_BBVN;goto extract_sfmt_bbv;
565
      case 32 : itype = IQ2000BF_INSN_LB;goto extract_sfmt_lb;
566
      case 33 : itype = IQ2000BF_INSN_LH;goto extract_sfmt_lh;
567
      case 35 : itype = IQ2000BF_INSN_LW;goto extract_sfmt_lw;
568
      case 36 : itype = IQ2000BF_INSN_LBU;goto extract_sfmt_lb;
569
      case 37 : itype = IQ2000BF_INSN_LHU;goto extract_sfmt_lh;
570
      case 39 : itype = IQ2000BF_INSN_RAM;goto extract_sfmt_ram;
571
      case 40 : itype = IQ2000BF_INSN_SB;goto extract_sfmt_sb;
572
      case 41 : itype = IQ2000BF_INSN_SH;goto extract_sfmt_sh;
573
      case 43 : itype = IQ2000BF_INSN_SW;goto extract_sfmt_sw;
574
      case 44 : itype = IQ2000BF_INSN_ANDOI;goto extract_sfmt_addi;
575
      case 45 : itype = IQ2000BF_INSN_BMB;goto extract_sfmt_bbv;
576
      case 47 : itype = IQ2000BF_INSN_ORUI;goto extract_sfmt_andoui;
577
      case 48 : itype = IQ2000BF_INSN_LDW;goto extract_sfmt_ldw;
578
      case 56 : itype = IQ2000BF_INSN_SDW;goto extract_sfmt_sdw;
579
      case 63 : itype = IQ2000BF_INSN_ANDOUI;goto extract_sfmt_andoui;
580
      default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
581
      }
582
    }
583
  }
584
 
585
  /* The instruction has been decoded, now extract the fields.  */
586
 
587
 extract_sfmt_empty:
588
  {
589
    const IDESC *idesc = &iq2000bf_insn_data[itype];
590
#define FLD(f) abuf->fields.fmt_empty.f
591
 
592
 
593
  /* Record the fields for the semantic handler.  */
594
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_empty", (char *) 0));
595
 
596
#undef FLD
597
    return idesc;
598
  }
599
 
600
 extract_sfmt_add:
601
  {
602
    const IDESC *idesc = &iq2000bf_insn_data[itype];
603
    CGEN_INSN_INT insn = entire_insn;
604
#define FLD(f) abuf->fields.sfmt_mrgb.f
605
    UINT f_rs;
606
    UINT f_rt;
607
    UINT f_rd;
608
 
609
    f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
610
    f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
611
    f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 5);
612
 
613
  /* Record the fields for the semantic handler.  */
614
  FLD (f_rs) = f_rs;
615
  FLD (f_rt) = f_rt;
616
  FLD (f_rd) = f_rd;
617
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_add", "f_rs 0x%x", 'x', f_rs, "f_rt 0x%x", 'x', f_rt, "f_rd 0x%x", 'x', f_rd, (char *) 0));
618
 
619
#undef FLD
620
    return idesc;
621
  }
622
 
623
 extract_sfmt_addi:
624
  {
625
    const IDESC *idesc = &iq2000bf_insn_data[itype];
626
    CGEN_INSN_INT insn = entire_insn;
627
#define FLD(f) abuf->fields.sfmt_addi.f
628
    UINT f_rs;
629
    UINT f_rt;
630
    UINT f_imm;
631
 
632
    f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
633
    f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
634
    f_imm = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
635
 
636
  /* Record the fields for the semantic handler.  */
637
  FLD (f_imm) = f_imm;
638
  FLD (f_rs) = f_rs;
639
  FLD (f_rt) = f_rt;
640
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_addi", "f_imm 0x%x", 'x', f_imm, "f_rs 0x%x", 'x', f_rs, "f_rt 0x%x", 'x', f_rt, (char *) 0));
641
 
642
#undef FLD
643
    return idesc;
644
  }
645
 
646
 extract_sfmt_ado16:
647
  {
648
    const IDESC *idesc = &iq2000bf_insn_data[itype];
649
    CGEN_INSN_INT insn = entire_insn;
650
#define FLD(f) abuf->fields.sfmt_mrgb.f
651
    UINT f_rs;
652
    UINT f_rt;
653
    UINT f_rd;
654
 
655
    f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
656
    f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
657
    f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 5);
658
 
659
  /* Record the fields for the semantic handler.  */
660
  FLD (f_rs) = f_rs;
661
  FLD (f_rt) = f_rt;
662
  FLD (f_rd) = f_rd;
663
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ado16", "f_rs 0x%x", 'x', f_rs, "f_rt 0x%x", 'x', f_rt, "f_rd 0x%x", 'x', f_rd, (char *) 0));
664
 
665
#undef FLD
666
    return idesc;
667
  }
668
 
669
 extract_sfmt_ram:
670
  {
671
    const IDESC *idesc = &iq2000bf_insn_data[itype];
672
    CGEN_INSN_INT insn = entire_insn;
673
#define FLD(f) abuf->fields.sfmt_ram.f
674
    UINT f_rs;
675
    UINT f_rt;
676
    UINT f_rd;
677
    UINT f_shamt;
678
    UINT f_maskl;
679
 
680
    f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
681
    f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
682
    f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 5);
683
    f_shamt = EXTRACT_LSB0_UINT (insn, 32, 10, 5);
684
    f_maskl = EXTRACT_LSB0_UINT (insn, 32, 4, 5);
685
 
686
  /* Record the fields for the semantic handler.  */
687
  FLD (f_maskl) = f_maskl;
688
  FLD (f_rs) = f_rs;
689
  FLD (f_rd) = f_rd;
690
  FLD (f_rt) = f_rt;
691
  FLD (f_shamt) = f_shamt;
692
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ram", "f_maskl 0x%x", 'x', f_maskl, "f_rs 0x%x", 'x', f_rs, "f_rd 0x%x", 'x', f_rd, "f_rt 0x%x", 'x', f_rt, "f_shamt 0x%x", 'x', f_shamt, (char *) 0));
693
 
694
#undef FLD
695
    return idesc;
696
  }
697
 
698
 extract_sfmt_sll:
699
  {
700
    const IDESC *idesc = &iq2000bf_insn_data[itype];
701
    CGEN_INSN_INT insn = entire_insn;
702
#define FLD(f) abuf->fields.sfmt_ram.f
703
    UINT f_rt;
704
    UINT f_rd;
705
    UINT f_shamt;
706
 
707
    f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
708
    f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 5);
709
    f_shamt = EXTRACT_LSB0_UINT (insn, 32, 10, 5);
710
 
711
  /* Record the fields for the semantic handler.  */
712
  FLD (f_rt) = f_rt;
713
  FLD (f_shamt) = f_shamt;
714
  FLD (f_rd) = f_rd;
715
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_sll", "f_rt 0x%x", 'x', f_rt, "f_shamt 0x%x", 'x', f_shamt, "f_rd 0x%x", 'x', f_rd, (char *) 0));
716
 
717
#undef FLD
718
    return idesc;
719
  }
720
 
721
 extract_sfmt_slmv:
722
  {
723
    const IDESC *idesc = &iq2000bf_insn_data[itype];
724
    CGEN_INSN_INT insn = entire_insn;
725
#define FLD(f) abuf->fields.sfmt_ram.f
726
    UINT f_rs;
727
    UINT f_rt;
728
    UINT f_rd;
729
    UINT f_shamt;
730
 
731
    f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
732
    f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
733
    f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 5);
734
    f_shamt = EXTRACT_LSB0_UINT (insn, 32, 10, 5);
735
 
736
  /* Record the fields for the semantic handler.  */
737
  FLD (f_rs) = f_rs;
738
  FLD (f_rt) = f_rt;
739
  FLD (f_shamt) = f_shamt;
740
  FLD (f_rd) = f_rd;
741
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_slmv", "f_rs 0x%x", 'x', f_rs, "f_rt 0x%x", 'x', f_rt, "f_shamt 0x%x", 'x', f_shamt, "f_rd 0x%x", 'x', f_rd, (char *) 0));
742
 
743
#undef FLD
744
    return idesc;
745
  }
746
 
747
 extract_sfmt_slt:
748
  {
749
    const IDESC *idesc = &iq2000bf_insn_data[itype];
750
    CGEN_INSN_INT insn = entire_insn;
751
#define FLD(f) abuf->fields.sfmt_mrgb.f
752
    UINT f_rs;
753
    UINT f_rt;
754
    UINT f_rd;
755
 
756
    f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
757
    f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
758
    f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 5);
759
 
760
  /* Record the fields for the semantic handler.  */
761
  FLD (f_rs) = f_rs;
762
  FLD (f_rt) = f_rt;
763
  FLD (f_rd) = f_rd;
764
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_slt", "f_rs 0x%x", 'x', f_rs, "f_rt 0x%x", 'x', f_rt, "f_rd 0x%x", 'x', f_rd, (char *) 0));
765
 
766
#undef FLD
767
    return idesc;
768
  }
769
 
770
 extract_sfmt_slti:
771
  {
772
    const IDESC *idesc = &iq2000bf_insn_data[itype];
773
    CGEN_INSN_INT insn = entire_insn;
774
#define FLD(f) abuf->fields.sfmt_addi.f
775
    UINT f_rs;
776
    UINT f_rt;
777
    UINT f_imm;
778
 
779
    f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
780
    f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
781
    f_imm = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
782
 
783
  /* Record the fields for the semantic handler.  */
784
  FLD (f_imm) = f_imm;
785
  FLD (f_rs) = f_rs;
786
  FLD (f_rt) = f_rt;
787
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_slti", "f_imm 0x%x", 'x', f_imm, "f_rs 0x%x", 'x', f_rs, "f_rt 0x%x", 'x', f_rt, (char *) 0));
788
 
789
#undef FLD
790
    return idesc;
791
  }
792
 
793
 extract_sfmt_bbi:
794
  {
795
    const IDESC *idesc = &iq2000bf_insn_data[itype];
796
    CGEN_INSN_INT insn = entire_insn;
797
#define FLD(f) abuf->fields.sfmt_bbi.f
798
    UINT f_rs;
799
    UINT f_rt;
800
    SI f_offset;
801
 
802
    f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
803
    f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
804
    f_offset = ((((EXTRACT_LSB0_INT (insn, 32, 15, 16)) << (2))) + (((pc) + (4))));
805
 
806
  /* Record the fields for the semantic handler.  */
807
  FLD (f_rt) = f_rt;
808
  FLD (f_rs) = f_rs;
809
  FLD (i_offset) = f_offset;
810
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_bbi", "f_rt 0x%x", 'x', f_rt, "f_rs 0x%x", 'x', f_rs, "offset 0x%x", 'x', f_offset, (char *) 0));
811
 
812
#if WITH_PROFILE_MODEL_P
813
  /* Record the fields for profiling.  */
814
  if (PROFILE_MODEL_P (current_cpu))
815
    {
816
    }
817
#endif
818
#undef FLD
819
    return idesc;
820
  }
821
 
822
 extract_sfmt_bbv:
823
  {
824
    const IDESC *idesc = &iq2000bf_insn_data[itype];
825
    CGEN_INSN_INT insn = entire_insn;
826
#define FLD(f) abuf->fields.sfmt_bbi.f
827
    UINT f_rs;
828
    UINT f_rt;
829
    SI f_offset;
830
 
831
    f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
832
    f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
833
    f_offset = ((((EXTRACT_LSB0_INT (insn, 32, 15, 16)) << (2))) + (((pc) + (4))));
834
 
835
  /* Record the fields for the semantic handler.  */
836
  FLD (f_rs) = f_rs;
837
  FLD (f_rt) = f_rt;
838
  FLD (i_offset) = f_offset;
839
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_bbv", "f_rs 0x%x", 'x', f_rs, "f_rt 0x%x", 'x', f_rt, "offset 0x%x", 'x', f_offset, (char *) 0));
840
 
841
#if WITH_PROFILE_MODEL_P
842
  /* Record the fields for profiling.  */
843
  if (PROFILE_MODEL_P (current_cpu))
844
    {
845
    }
846
#endif
847
#undef FLD
848
    return idesc;
849
  }
850
 
851
 extract_sfmt_bgez:
852
  {
853
    const IDESC *idesc = &iq2000bf_insn_data[itype];
854
    CGEN_INSN_INT insn = entire_insn;
855
#define FLD(f) abuf->fields.sfmt_bbi.f
856
    UINT f_rs;
857
    SI f_offset;
858
 
859
    f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
860
    f_offset = ((((EXTRACT_LSB0_INT (insn, 32, 15, 16)) << (2))) + (((pc) + (4))));
861
 
862
  /* Record the fields for the semantic handler.  */
863
  FLD (f_rs) = f_rs;
864
  FLD (i_offset) = f_offset;
865
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_bgez", "f_rs 0x%x", 'x', f_rs, "offset 0x%x", 'x', f_offset, (char *) 0));
866
 
867
#if WITH_PROFILE_MODEL_P
868
  /* Record the fields for profiling.  */
869
  if (PROFILE_MODEL_P (current_cpu))
870
    {
871
    }
872
#endif
873
#undef FLD
874
    return idesc;
875
  }
876
 
877
 extract_sfmt_bgezal:
878
  {
879
    const IDESC *idesc = &iq2000bf_insn_data[itype];
880
    CGEN_INSN_INT insn = entire_insn;
881
#define FLD(f) abuf->fields.sfmt_bbi.f
882
    UINT f_rs;
883
    SI f_offset;
884
 
885
    f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
886
    f_offset = ((((EXTRACT_LSB0_INT (insn, 32, 15, 16)) << (2))) + (((pc) + (4))));
887
 
888
  /* Record the fields for the semantic handler.  */
889
  FLD (f_rs) = f_rs;
890
  FLD (i_offset) = f_offset;
891
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_bgezal", "f_rs 0x%x", 'x', f_rs, "offset 0x%x", 'x', f_offset, (char *) 0));
892
 
893
#if WITH_PROFILE_MODEL_P
894
  /* Record the fields for profiling.  */
895
  if (PROFILE_MODEL_P (current_cpu))
896
    {
897
    }
898
#endif
899
#undef FLD
900
    return idesc;
901
  }
902
 
903
 extract_sfmt_jalr:
904
  {
905
    const IDESC *idesc = &iq2000bf_insn_data[itype];
906
    CGEN_INSN_INT insn = entire_insn;
907
#define FLD(f) abuf->fields.sfmt_mrgb.f
908
    UINT f_rs;
909
    UINT f_rd;
910
 
911
    f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
912
    f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 5);
913
 
914
  /* Record the fields for the semantic handler.  */
915
  FLD (f_rs) = f_rs;
916
  FLD (f_rd) = f_rd;
917
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_jalr", "f_rs 0x%x", 'x', f_rs, "f_rd 0x%x", 'x', f_rd, (char *) 0));
918
 
919
#if WITH_PROFILE_MODEL_P
920
  /* Record the fields for profiling.  */
921
  if (PROFILE_MODEL_P (current_cpu))
922
    {
923
    }
924
#endif
925
#undef FLD
926
    return idesc;
927
  }
928
 
929
 extract_sfmt_jr:
930
  {
931
    const IDESC *idesc = &iq2000bf_insn_data[itype];
932
    CGEN_INSN_INT insn = entire_insn;
933
#define FLD(f) abuf->fields.sfmt_bbi.f
934
    UINT f_rs;
935
 
936
    f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
937
 
938
  /* Record the fields for the semantic handler.  */
939
  FLD (f_rs) = f_rs;
940
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_jr", "f_rs 0x%x", 'x', f_rs, (char *) 0));
941
 
942
#if WITH_PROFILE_MODEL_P
943
  /* Record the fields for profiling.  */
944
  if (PROFILE_MODEL_P (current_cpu))
945
    {
946
    }
947
#endif
948
#undef FLD
949
    return idesc;
950
  }
951
 
952
 extract_sfmt_lb:
953
  {
954
    const IDESC *idesc = &iq2000bf_insn_data[itype];
955
    CGEN_INSN_INT insn = entire_insn;
956
#define FLD(f) abuf->fields.sfmt_addi.f
957
    UINT f_rs;
958
    UINT f_rt;
959
    UINT f_imm;
960
 
961
    f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
962
    f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
963
    f_imm = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
964
 
965
  /* Record the fields for the semantic handler.  */
966
  FLD (f_rs) = f_rs;
967
  FLD (f_imm) = f_imm;
968
  FLD (f_rt) = f_rt;
969
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_lb", "f_rs 0x%x", 'x', f_rs, "f_imm 0x%x", 'x', f_imm, "f_rt 0x%x", 'x', f_rt, (char *) 0));
970
 
971
#undef FLD
972
    return idesc;
973
  }
974
 
975
 extract_sfmt_lh:
976
  {
977
    const IDESC *idesc = &iq2000bf_insn_data[itype];
978
    CGEN_INSN_INT insn = entire_insn;
979
#define FLD(f) abuf->fields.sfmt_addi.f
980
    UINT f_rs;
981
    UINT f_rt;
982
    UINT f_imm;
983
 
984
    f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
985
    f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
986
    f_imm = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
987
 
988
  /* Record the fields for the semantic handler.  */
989
  FLD (f_rs) = f_rs;
990
  FLD (f_imm) = f_imm;
991
  FLD (f_rt) = f_rt;
992
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_lh", "f_rs 0x%x", 'x', f_rs, "f_imm 0x%x", 'x', f_imm, "f_rt 0x%x", 'x', f_rt, (char *) 0));
993
 
994
#undef FLD
995
    return idesc;
996
  }
997
 
998
 extract_sfmt_lui:
999
  {
1000
    const IDESC *idesc = &iq2000bf_insn_data[itype];
1001
    CGEN_INSN_INT insn = entire_insn;
1002
#define FLD(f) abuf->fields.sfmt_addi.f
1003
    UINT f_rt;
1004
    UINT f_imm;
1005
 
1006
    f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
1007
    f_imm = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
1008
 
1009
  /* Record the fields for the semantic handler.  */
1010
  FLD (f_imm) = f_imm;
1011
  FLD (f_rt) = f_rt;
1012
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_lui", "f_imm 0x%x", 'x', f_imm, "f_rt 0x%x", 'x', f_rt, (char *) 0));
1013
 
1014
#undef FLD
1015
    return idesc;
1016
  }
1017
 
1018
 extract_sfmt_lw:
1019
  {
1020
    const IDESC *idesc = &iq2000bf_insn_data[itype];
1021
    CGEN_INSN_INT insn = entire_insn;
1022
#define FLD(f) abuf->fields.sfmt_addi.f
1023
    UINT f_rs;
1024
    UINT f_rt;
1025
    UINT f_imm;
1026
 
1027
    f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
1028
    f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
1029
    f_imm = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
1030
 
1031
  /* Record the fields for the semantic handler.  */
1032
  FLD (f_rs) = f_rs;
1033
  FLD (f_imm) = f_imm;
1034
  FLD (f_rt) = f_rt;
1035
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_lw", "f_rs 0x%x", 'x', f_rs, "f_imm 0x%x", 'x', f_imm, "f_rt 0x%x", 'x', f_rt, (char *) 0));
1036
 
1037
#undef FLD
1038
    return idesc;
1039
  }
1040
 
1041
 extract_sfmt_sb:
1042
  {
1043
    const IDESC *idesc = &iq2000bf_insn_data[itype];
1044
    CGEN_INSN_INT insn = entire_insn;
1045
#define FLD(f) abuf->fields.sfmt_addi.f
1046
    UINT f_rs;
1047
    UINT f_rt;
1048
    UINT f_imm;
1049
 
1050
    f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
1051
    f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
1052
    f_imm = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
1053
 
1054
  /* Record the fields for the semantic handler.  */
1055
  FLD (f_rs) = f_rs;
1056
  FLD (f_imm) = f_imm;
1057
  FLD (f_rt) = f_rt;
1058
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_sb", "f_rs 0x%x", 'x', f_rs, "f_imm 0x%x", 'x', f_imm, "f_rt 0x%x", 'x', f_rt, (char *) 0));
1059
 
1060
#undef FLD
1061
    return idesc;
1062
  }
1063
 
1064
 extract_sfmt_sh:
1065
  {
1066
    const IDESC *idesc = &iq2000bf_insn_data[itype];
1067
    CGEN_INSN_INT insn = entire_insn;
1068
#define FLD(f) abuf->fields.sfmt_addi.f
1069
    UINT f_rs;
1070
    UINT f_rt;
1071
    UINT f_imm;
1072
 
1073
    f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
1074
    f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
1075
    f_imm = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
1076
 
1077
  /* Record the fields for the semantic handler.  */
1078
  FLD (f_rs) = f_rs;
1079
  FLD (f_imm) = f_imm;
1080
  FLD (f_rt) = f_rt;
1081
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_sh", "f_rs 0x%x", 'x', f_rs, "f_imm 0x%x", 'x', f_imm, "f_rt 0x%x", 'x', f_rt, (char *) 0));
1082
 
1083
#undef FLD
1084
    return idesc;
1085
  }
1086
 
1087
 extract_sfmt_sw:
1088
  {
1089
    const IDESC *idesc = &iq2000bf_insn_data[itype];
1090
    CGEN_INSN_INT insn = entire_insn;
1091
#define FLD(f) abuf->fields.sfmt_addi.f
1092
    UINT f_rs;
1093
    UINT f_rt;
1094
    UINT f_imm;
1095
 
1096
    f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
1097
    f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
1098
    f_imm = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
1099
 
1100
  /* Record the fields for the semantic handler.  */
1101
  FLD (f_rs) = f_rs;
1102
  FLD (f_imm) = f_imm;
1103
  FLD (f_rt) = f_rt;
1104
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_sw", "f_rs 0x%x", 'x', f_rs, "f_imm 0x%x", 'x', f_imm, "f_rt 0x%x", 'x', f_rt, (char *) 0));
1105
 
1106
#undef FLD
1107
    return idesc;
1108
  }
1109
 
1110
 extract_sfmt_break:
1111
  {
1112
    const IDESC *idesc = &iq2000bf_insn_data[itype];
1113
#define FLD(f) abuf->fields.fmt_empty.f
1114
 
1115
 
1116
  /* Record the fields for the semantic handler.  */
1117
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_break", (char *) 0));
1118
 
1119
#if WITH_PROFILE_MODEL_P
1120
  /* Record the fields for profiling.  */
1121
  if (PROFILE_MODEL_P (current_cpu))
1122
    {
1123
    }
1124
#endif
1125
#undef FLD
1126
    return idesc;
1127
  }
1128
 
1129
 extract_sfmt_syscall:
1130
  {
1131
    const IDESC *idesc = &iq2000bf_insn_data[itype];
1132
#define FLD(f) abuf->fields.fmt_empty.f
1133
 
1134
 
1135
  /* Record the fields for the semantic handler.  */
1136
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_syscall", (char *) 0));
1137
 
1138
#undef FLD
1139
    return idesc;
1140
  }
1141
 
1142
 extract_sfmt_andoui:
1143
  {
1144
    const IDESC *idesc = &iq2000bf_insn_data[itype];
1145
    CGEN_INSN_INT insn = entire_insn;
1146
#define FLD(f) abuf->fields.sfmt_addi.f
1147
    UINT f_rs;
1148
    UINT f_rt;
1149
    UINT f_imm;
1150
 
1151
    f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
1152
    f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
1153
    f_imm = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
1154
 
1155
  /* Record the fields for the semantic handler.  */
1156
  FLD (f_imm) = f_imm;
1157
  FLD (f_rs) = f_rs;
1158
  FLD (f_rt) = f_rt;
1159
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_andoui", "f_imm 0x%x", 'x', f_imm, "f_rs 0x%x", 'x', f_rs, "f_rt 0x%x", 'x', f_rt, (char *) 0));
1160
 
1161
#undef FLD
1162
    return idesc;
1163
  }
1164
 
1165
 extract_sfmt_mrgb:
1166
  {
1167
    const IDESC *idesc = &iq2000bf_insn_data[itype];
1168
    CGEN_INSN_INT insn = entire_insn;
1169
#define FLD(f) abuf->fields.sfmt_mrgb.f
1170
    UINT f_rs;
1171
    UINT f_rt;
1172
    UINT f_rd;
1173
    UINT f_mask;
1174
 
1175
    f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
1176
    f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
1177
    f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 5);
1178
    f_mask = EXTRACT_LSB0_UINT (insn, 32, 9, 4);
1179
 
1180
  /* Record the fields for the semantic handler.  */
1181
  FLD (f_mask) = f_mask;
1182
  FLD (f_rs) = f_rs;
1183
  FLD (f_rt) = f_rt;
1184
  FLD (f_rd) = f_rd;
1185
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_mrgb", "f_mask 0x%x", 'x', f_mask, "f_rs 0x%x", 'x', f_rs, "f_rt 0x%x", 'x', f_rt, "f_rd 0x%x", 'x', f_rd, (char *) 0));
1186
 
1187
#undef FLD
1188
    return idesc;
1189
  }
1190
 
1191
 extract_sfmt_bctxt:
1192
  {
1193
    const IDESC *idesc = &iq2000bf_insn_data[itype];
1194
#define FLD(f) abuf->fields.fmt_empty.f
1195
 
1196
 
1197
  /* Record the fields for the semantic handler.  */
1198
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_bctxt", (char *) 0));
1199
 
1200
#undef FLD
1201
    return idesc;
1202
  }
1203
 
1204
 extract_sfmt_ldw:
1205
  {
1206
    const IDESC *idesc = &iq2000bf_insn_data[itype];
1207
    CGEN_INSN_INT insn = entire_insn;
1208
#define FLD(f) abuf->fields.sfmt_addi.f
1209
    UINT f_rs;
1210
    UINT f_rt;
1211
    UINT f_imm;
1212
 
1213
    f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
1214
    f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
1215
    f_imm = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
1216
 
1217
  /* Record the fields for the semantic handler.  */
1218
  FLD (f_rs) = f_rs;
1219
  FLD (f_rt) = f_rt;
1220
  FLD (f_imm) = f_imm;
1221
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldw", "f_rs 0x%x", 'x', f_rs, "f_rt 0x%x", 'x', f_rt, "f_imm 0x%x", 'x', f_imm, (char *) 0));
1222
 
1223
#undef FLD
1224
    return idesc;
1225
  }
1226
 
1227
 extract_sfmt_sdw:
1228
  {
1229
    const IDESC *idesc = &iq2000bf_insn_data[itype];
1230
    CGEN_INSN_INT insn = entire_insn;
1231
#define FLD(f) abuf->fields.sfmt_addi.f
1232
    UINT f_rs;
1233
    UINT f_rt;
1234
    UINT f_imm;
1235
 
1236
    f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
1237
    f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
1238
    f_imm = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
1239
 
1240
  /* Record the fields for the semantic handler.  */
1241
  FLD (f_rs) = f_rs;
1242
  FLD (f_rt) = f_rt;
1243
  FLD (f_imm) = f_imm;
1244
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_sdw", "f_rs 0x%x", 'x', f_rs, "f_rt 0x%x", 'x', f_rt, "f_imm 0x%x", 'x', f_imm, (char *) 0));
1245
 
1246
#undef FLD
1247
    return idesc;
1248
  }
1249
 
1250
 extract_sfmt_j:
1251
  {
1252
    const IDESC *idesc = &iq2000bf_insn_data[itype];
1253
    CGEN_INSN_INT insn = entire_insn;
1254
#define FLD(f) abuf->fields.sfmt_j.f
1255
    USI f_jtarg;
1256
 
1257
    f_jtarg = ((((pc) & (0xf0000000))) | (((EXTRACT_LSB0_UINT (insn, 32, 15, 16)) << (2))));
1258
 
1259
  /* Record the fields for the semantic handler.  */
1260
  FLD (i_jmptarg) = f_jtarg;
1261
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_j", "jmptarg 0x%x", 'x', f_jtarg, (char *) 0));
1262
 
1263
#if WITH_PROFILE_MODEL_P
1264
  /* Record the fields for profiling.  */
1265
  if (PROFILE_MODEL_P (current_cpu))
1266
    {
1267
    }
1268
#endif
1269
#undef FLD
1270
    return idesc;
1271
  }
1272
 
1273
 extract_sfmt_jal:
1274
  {
1275
    const IDESC *idesc = &iq2000bf_insn_data[itype];
1276
    CGEN_INSN_INT insn = entire_insn;
1277
#define FLD(f) abuf->fields.sfmt_j.f
1278
    USI f_jtarg;
1279
 
1280
    f_jtarg = ((((pc) & (0xf0000000))) | (((EXTRACT_LSB0_UINT (insn, 32, 15, 16)) << (2))));
1281
 
1282
  /* Record the fields for the semantic handler.  */
1283
  FLD (i_jmptarg) = f_jtarg;
1284
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_jal", "jmptarg 0x%x", 'x', f_jtarg, (char *) 0));
1285
 
1286
#if WITH_PROFILE_MODEL_P
1287
  /* Record the fields for profiling.  */
1288
  if (PROFILE_MODEL_P (current_cpu))
1289
    {
1290
    }
1291
#endif
1292
#undef FLD
1293
    return idesc;
1294
  }
1295
 
1296
}

powered by: WebSVN 2.1.0

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