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