?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gas/
[binutils-gdb.git] / sim / iq2000 / sem-switch.c
blob845fc32309ffdcc9a34980f4f77d595502aaf001
1 /* Simulator instruction semantics 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 #ifdef DEFINE_LABELS
25
26 /* The labels have the case they have because the enum of insn types
27 is all uppercase and in the non-stdc case the insn symbol is built
28 into the enum name. */
29
30 static struct {
31 int index;
32 void *label;
33 } labels[] = {
34 { IQ2000BF_INSN_X_INVALID, && case_sem_INSN_X_INVALID },
35 { IQ2000BF_INSN_X_AFTER, && case_sem_INSN_X_AFTER },
36 { IQ2000BF_INSN_X_BEFORE, && case_sem_INSN_X_BEFORE },
37 { IQ2000BF_INSN_X_CTI_CHAIN, && case_sem_INSN_X_CTI_CHAIN },
38 { IQ2000BF_INSN_X_CHAIN, && case_sem_INSN_X_CHAIN },
39 { IQ2000BF_INSN_X_BEGIN, && case_sem_INSN_X_BEGIN },
40 { IQ2000BF_INSN_ADD, && case_sem_INSN_ADD },
41 { IQ2000BF_INSN_ADDI, && case_sem_INSN_ADDI },
42 { IQ2000BF_INSN_ADDIU, && case_sem_INSN_ADDIU },
43 { IQ2000BF_INSN_ADDU, && case_sem_INSN_ADDU },
44 { IQ2000BF_INSN_ADO16, && case_sem_INSN_ADO16 },
45 { IQ2000BF_INSN_AND, && case_sem_INSN_AND },
46 { IQ2000BF_INSN_ANDI, && case_sem_INSN_ANDI },
47 { IQ2000BF_INSN_ANDOI, && case_sem_INSN_ANDOI },
48 { IQ2000BF_INSN_NOR, && case_sem_INSN_NOR },
49 { IQ2000BF_INSN_OR, && case_sem_INSN_OR },
50 { IQ2000BF_INSN_ORI, && case_sem_INSN_ORI },
51 { IQ2000BF_INSN_RAM, && case_sem_INSN_RAM },
52 { IQ2000BF_INSN_SLL, && case_sem_INSN_SLL },
53 { IQ2000BF_INSN_SLLV, && case_sem_INSN_SLLV },
54 { IQ2000BF_INSN_SLMV, && case_sem_INSN_SLMV },
55 { IQ2000BF_INSN_SLT, && case_sem_INSN_SLT },
56 { IQ2000BF_INSN_SLTI, && case_sem_INSN_SLTI },
57 { IQ2000BF_INSN_SLTIU, && case_sem_INSN_SLTIU },
58 { IQ2000BF_INSN_SLTU, && case_sem_INSN_SLTU },
59 { IQ2000BF_INSN_SRA, && case_sem_INSN_SRA },
60 { IQ2000BF_INSN_SRAV, && case_sem_INSN_SRAV },
61 { IQ2000BF_INSN_SRL, && case_sem_INSN_SRL },
62 { IQ2000BF_INSN_SRLV, && case_sem_INSN_SRLV },
63 { IQ2000BF_INSN_SRMV, && case_sem_INSN_SRMV },
64 { IQ2000BF_INSN_SUB, && case_sem_INSN_SUB },
65 { IQ2000BF_INSN_SUBU, && case_sem_INSN_SUBU },
66 { IQ2000BF_INSN_XOR, && case_sem_INSN_XOR },
67 { IQ2000BF_INSN_XORI, && case_sem_INSN_XORI },
68 { IQ2000BF_INSN_BBI, && case_sem_INSN_BBI },
69 { IQ2000BF_INSN_BBIN, && case_sem_INSN_BBIN },
70 { IQ2000BF_INSN_BBV, && case_sem_INSN_BBV },
71 { IQ2000BF_INSN_BBVN, && case_sem_INSN_BBVN },
72 { IQ2000BF_INSN_BEQ, && case_sem_INSN_BEQ },
73 { IQ2000BF_INSN_BEQL, && case_sem_INSN_BEQL },
74 { IQ2000BF_INSN_BGEZ, && case_sem_INSN_BGEZ },
75 { IQ2000BF_INSN_BGEZAL, && case_sem_INSN_BGEZAL },
76 { IQ2000BF_INSN_BGEZALL, && case_sem_INSN_BGEZALL },
77 { IQ2000BF_INSN_BGEZL, && case_sem_INSN_BGEZL },
78 { IQ2000BF_INSN_BLTZ, && case_sem_INSN_BLTZ },
79 { IQ2000BF_INSN_BLTZL, && case_sem_INSN_BLTZL },
80 { IQ2000BF_INSN_BLTZAL, && case_sem_INSN_BLTZAL },
81 { IQ2000BF_INSN_BLTZALL, && case_sem_INSN_BLTZALL },
82 { IQ2000BF_INSN_BMB0, && case_sem_INSN_BMB0 },
83 { IQ2000BF_INSN_BMB1, && case_sem_INSN_BMB1 },
84 { IQ2000BF_INSN_BMB2, && case_sem_INSN_BMB2 },
85 { IQ2000BF_INSN_BMB3, && case_sem_INSN_BMB3 },
86 { IQ2000BF_INSN_BNE, && case_sem_INSN_BNE },
87 { IQ2000BF_INSN_BNEL, && case_sem_INSN_BNEL },
88 { IQ2000BF_INSN_JALR, && case_sem_INSN_JALR },
89 { IQ2000BF_INSN_JR, && case_sem_INSN_JR },
90 { IQ2000BF_INSN_LB, && case_sem_INSN_LB },
91 { IQ2000BF_INSN_LBU, && case_sem_INSN_LBU },
92 { IQ2000BF_INSN_LH, && case_sem_INSN_LH },
93 { IQ2000BF_INSN_LHU, && case_sem_INSN_LHU },
94 { IQ2000BF_INSN_LUI, && case_sem_INSN_LUI },
95 { IQ2000BF_INSN_LW, && case_sem_INSN_LW },
96 { IQ2000BF_INSN_SB, && case_sem_INSN_SB },
97 { IQ2000BF_INSN_SH, && case_sem_INSN_SH },
98 { IQ2000BF_INSN_SW, && case_sem_INSN_SW },
99 { IQ2000BF_INSN_BREAK, && case_sem_INSN_BREAK },
100 { IQ2000BF_INSN_SYSCALL, && case_sem_INSN_SYSCALL },
101 { IQ2000BF_INSN_ANDOUI, && case_sem_INSN_ANDOUI },
102 { IQ2000BF_INSN_ORUI, && case_sem_INSN_ORUI },
103 { IQ2000BF_INSN_BGTZ, && case_sem_INSN_BGTZ },
104 { IQ2000BF_INSN_BGTZL, && case_sem_INSN_BGTZL },
105 { IQ2000BF_INSN_BLEZ, && case_sem_INSN_BLEZ },
106 { IQ2000BF_INSN_BLEZL, && case_sem_INSN_BLEZL },
107 { IQ2000BF_INSN_MRGB, && case_sem_INSN_MRGB },
108 { IQ2000BF_INSN_BCTXT, && case_sem_INSN_BCTXT },
109 { IQ2000BF_INSN_BC0F, && case_sem_INSN_BC0F },
110 { IQ2000BF_INSN_BC0FL, && case_sem_INSN_BC0FL },
111 { IQ2000BF_INSN_BC3F, && case_sem_INSN_BC3F },
112 { IQ2000BF_INSN_BC3FL, && case_sem_INSN_BC3FL },
113 { IQ2000BF_INSN_BC0T, && case_sem_INSN_BC0T },
114 { IQ2000BF_INSN_BC0TL, && case_sem_INSN_BC0TL },
115 { IQ2000BF_INSN_BC3T, && case_sem_INSN_BC3T },
116 { IQ2000BF_INSN_BC3TL, && case_sem_INSN_BC3TL },
117 { IQ2000BF_INSN_CFC0, && case_sem_INSN_CFC0 },
118 { IQ2000BF_INSN_CFC1, && case_sem_INSN_CFC1 },
119 { IQ2000BF_INSN_CFC2, && case_sem_INSN_CFC2 },
120 { IQ2000BF_INSN_CFC3, && case_sem_INSN_CFC3 },
121 { IQ2000BF_INSN_CHKHDR, && case_sem_INSN_CHKHDR },
122 { IQ2000BF_INSN_CTC0, && case_sem_INSN_CTC0 },
123 { IQ2000BF_INSN_CTC1, && case_sem_INSN_CTC1 },
124 { IQ2000BF_INSN_CTC2, && case_sem_INSN_CTC2 },
125 { IQ2000BF_INSN_CTC3, && case_sem_INSN_CTC3 },
126 { IQ2000BF_INSN_JCR, && case_sem_INSN_JCR },
127 { IQ2000BF_INSN_LUC32, && case_sem_INSN_LUC32 },
128 { IQ2000BF_INSN_LUC32L, && case_sem_INSN_LUC32L },
129 { IQ2000BF_INSN_LUC64, && case_sem_INSN_LUC64 },
130 { IQ2000BF_INSN_LUC64L, && case_sem_INSN_LUC64L },
131 { IQ2000BF_INSN_LUK, && case_sem_INSN_LUK },
132 { IQ2000BF_INSN_LULCK, && case_sem_INSN_LULCK },
133 { IQ2000BF_INSN_LUM32, && case_sem_INSN_LUM32 },
134 { IQ2000BF_INSN_LUM32L, && case_sem_INSN_LUM32L },
135 { IQ2000BF_INSN_LUM64, && case_sem_INSN_LUM64 },
136 { IQ2000BF_INSN_LUM64L, && case_sem_INSN_LUM64L },
137 { IQ2000BF_INSN_LUR, && case_sem_INSN_LUR },
138 { IQ2000BF_INSN_LURL, && case_sem_INSN_LURL },
139 { IQ2000BF_INSN_LUULCK, && case_sem_INSN_LUULCK },
140 { IQ2000BF_INSN_MFC0, && case_sem_INSN_MFC0 },
141 { IQ2000BF_INSN_MFC1, && case_sem_INSN_MFC1 },
142 { IQ2000BF_INSN_MFC2, && case_sem_INSN_MFC2 },
143 { IQ2000BF_INSN_MFC3, && case_sem_INSN_MFC3 },
144 { IQ2000BF_INSN_MTC0, && case_sem_INSN_MTC0 },
145 { IQ2000BF_INSN_MTC1, && case_sem_INSN_MTC1 },
146 { IQ2000BF_INSN_MTC2, && case_sem_INSN_MTC2 },
147 { IQ2000BF_INSN_MTC3, && case_sem_INSN_MTC3 },
148 { IQ2000BF_INSN_PKRL, && case_sem_INSN_PKRL },
149 { IQ2000BF_INSN_PKRLR1, && case_sem_INSN_PKRLR1 },
150 { IQ2000BF_INSN_PKRLR30, && case_sem_INSN_PKRLR30 },
151 { IQ2000BF_INSN_RB, && case_sem_INSN_RB },
152 { IQ2000BF_INSN_RBR1, && case_sem_INSN_RBR1 },
153 { IQ2000BF_INSN_RBR30, && case_sem_INSN_RBR30 },
154 { IQ2000BF_INSN_RFE, && case_sem_INSN_RFE },
155 { IQ2000BF_INSN_RX, && case_sem_INSN_RX },
156 { IQ2000BF_INSN_RXR1, && case_sem_INSN_RXR1 },
157 { IQ2000BF_INSN_RXR30, && case_sem_INSN_RXR30 },
158 { IQ2000BF_INSN_SLEEP, && case_sem_INSN_SLEEP },
159 { IQ2000BF_INSN_SRRD, && case_sem_INSN_SRRD },
160 { IQ2000BF_INSN_SRRDL, && case_sem_INSN_SRRDL },
161 { IQ2000BF_INSN_SRULCK, && case_sem_INSN_SRULCK },
162 { IQ2000BF_INSN_SRWR, && case_sem_INSN_SRWR },
163 { IQ2000BF_INSN_SRWRU, && case_sem_INSN_SRWRU },
164 { IQ2000BF_INSN_TRAPQFL, && case_sem_INSN_TRAPQFL },
165 { IQ2000BF_INSN_TRAPQNE, && case_sem_INSN_TRAPQNE },
166 { IQ2000BF_INSN_TRAPREL, && case_sem_INSN_TRAPREL },
167 { IQ2000BF_INSN_WB, && case_sem_INSN_WB },
168 { IQ2000BF_INSN_WBU, && case_sem_INSN_WBU },
169 { IQ2000BF_INSN_WBR1, && case_sem_INSN_WBR1 },
170 { IQ2000BF_INSN_WBR1U, && case_sem_INSN_WBR1U },
171 { IQ2000BF_INSN_WBR30, && case_sem_INSN_WBR30 },
172 { IQ2000BF_INSN_WBR30U, && case_sem_INSN_WBR30U },
173 { IQ2000BF_INSN_WX, && case_sem_INSN_WX },
174 { IQ2000BF_INSN_WXU, && case_sem_INSN_WXU },
175 { IQ2000BF_INSN_WXR1, && case_sem_INSN_WXR1 },
176 { IQ2000BF_INSN_WXR1U, && case_sem_INSN_WXR1U },
177 { IQ2000BF_INSN_WXR30, && case_sem_INSN_WXR30 },
178 { IQ2000BF_INSN_WXR30U, && case_sem_INSN_WXR30U },
179 { IQ2000BF_INSN_LDW, && case_sem_INSN_LDW },
180 { IQ2000BF_INSN_SDW, && case_sem_INSN_SDW },
181 { IQ2000BF_INSN_J, && case_sem_INSN_J },
182 { IQ2000BF_INSN_JAL, && case_sem_INSN_JAL },
183 { IQ2000BF_INSN_BMB, && case_sem_INSN_BMB },
184 { 0, 0 }
185 };
186 int i;
187
188 for (i = 0; labels[i].label != 0; ++i)
189 {
190 #if FAST_P
191 CPU_IDESC (current_cpu) [labels[i].index].sem_fast_lab = labels[i].label;
192 #else
193 CPU_IDESC (current_cpu) [labels[i].index].sem_full_lab = labels[i].label;
194 #endif
195 }
196
197 #undef DEFINE_LABELS
198 #endif /* DEFINE_LABELS */
199
200 #ifdef DEFINE_SWITCH
201
202 /* If hyper-fast [well not unnecessarily slow] execution is selected, turn
203 off frills like tracing and profiling. */
204 /* FIXME: A better way would be to have TRACE_RESULT check for something
205 that can cause it to be optimized out. Another way would be to emit
206 special handlers into the instruction "stream". */
207
208 #if FAST_P
209 #undef TRACE_RESULT
210 #define TRACE_RESULT(cpu, abuf, name, type, val)
211 #endif
212
213 #undef GET_ATTR
214 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
215 #define GET_ATTR(cpu, num, attr) CGEN_ATTR_VALUE (NULL, abuf->idesc->attrs, CGEN_INSN_##attr)
216 #else
217 #define GET_ATTR(cpu, num, attr) CGEN_ATTR_VALUE (NULL, abuf->idesc->attrs, CGEN_INSN_/**/attr)
218 #endif
219
220 {
221
222 #if WITH_SCACHE_PBB
223
224 /* Branch to next handler without going around main loop. */
225 #define NEXT(vpc) goto * SEM_ARGBUF (vpc) -> semantic.sem_case
226 SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
227
228 #else /* ! WITH_SCACHE_PBB */
229
230 #define NEXT(vpc) BREAK (sem)
231 #ifdef __GNUC__
232 #if FAST_P
233 SWITCH (sem, SEM_ARGBUF (sc) -> idesc->sem_fast_lab)
234 #else
235 SWITCH (sem, SEM_ARGBUF (sc) -> idesc->sem_full_lab)
236 #endif
237 #else
238 SWITCH (sem, SEM_ARGBUF (sc) -> idesc->num)
239 #endif
240
241 #endif /* ! WITH_SCACHE_PBB */
242
243 {
244
245 CASE (sem, INSN_X_INVALID) : /* --invalid-- */
246 {
247 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
248 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
249 #define FLD(f) abuf->fields.fmt_empty.f
250 int UNUSED written = 0;
251 IADDR UNUSED pc = abuf->addr;
252 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
253
254 {
255 /* Update the recorded pc in the cpu state struct.
256 Only necessary for WITH_SCACHE case, but to avoid the
257 conditional compilation .... */
258 SET_H_PC (pc);
259 /* Virtual insns have zero size. Overwrite vpc with address of next insn
260 using the default-insn-bitsize spec. When executing insns in parallel
261 we may want to queue the fault and continue execution. */
262 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
263 vpc = sim_engine_invalid_insn (current_cpu, pc, vpc);
264 }
265
266 #undef FLD
267 }
268 NEXT (vpc);
269
270 CASE (sem, INSN_X_AFTER) : /* --after-- */
271 {
272 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
273 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
274 #define FLD(f) abuf->fields.fmt_empty.f
275 int UNUSED written = 0;
276 IADDR UNUSED pc = abuf->addr;
277 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
278
279 {
280 #if WITH_SCACHE_PBB_IQ2000BF
281 iq2000bf_pbb_after (current_cpu, sem_arg);
282 #endif
283 }
284
285 #undef FLD
286 }
287 NEXT (vpc);
288
289 CASE (sem, INSN_X_BEFORE) : /* --before-- */
290 {
291 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
292 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
293 #define FLD(f) abuf->fields.fmt_empty.f
294 int UNUSED written = 0;
295 IADDR UNUSED pc = abuf->addr;
296 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
297
298 {
299 #if WITH_SCACHE_PBB_IQ2000BF
300 iq2000bf_pbb_before (current_cpu, sem_arg);
301 #endif
302 }
303
304 #undef FLD
305 }
306 NEXT (vpc);
307
308 CASE (sem, INSN_X_CTI_CHAIN) : /* --cti-chain-- */
309 {
310 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
311 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
312 #define FLD(f) abuf->fields.fmt_empty.f
313 int UNUSED written = 0;
314 IADDR UNUSED pc = abuf->addr;
315 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
316
317 {
318 #if WITH_SCACHE_PBB_IQ2000BF
319 #ifdef DEFINE_SWITCH
320 vpc = iq2000bf_pbb_cti_chain (current_cpu, sem_arg,
321 pbb_br_type, pbb_br_npc);
322 BREAK (sem);
323 #else
324 /* FIXME: Allow provision of explicit ifmt spec in insn spec. */
325 vpc = iq2000bf_pbb_cti_chain (current_cpu, sem_arg,
326 CPU_PBB_BR_TYPE (current_cpu),
327 CPU_PBB_BR_NPC (current_cpu));
328 #endif
329 #endif
330 }
331
332 #undef FLD
333 }
334 NEXT (vpc);
335
336 CASE (sem, INSN_X_CHAIN) : /* --chain-- */
337 {
338 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
339 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
340 #define FLD(f) abuf->fields.fmt_empty.f
341 int UNUSED written = 0;
342 IADDR UNUSED pc = abuf->addr;
343 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
344
345 {
346 #if WITH_SCACHE_PBB_IQ2000BF
347 vpc = iq2000bf_pbb_chain (current_cpu, sem_arg);
348 #ifdef DEFINE_SWITCH
349 BREAK (sem);
350 #endif
351 #endif
352 }
353
354 #undef FLD
355 }
356 NEXT (vpc);
357
358 CASE (sem, INSN_X_BEGIN) : /* --begin-- */
359 {
360 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
361 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
362 #define FLD(f) abuf->fields.fmt_empty.f
363 int UNUSED written = 0;
364 IADDR UNUSED pc = abuf->addr;
365 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
366
367 {
368 #if WITH_SCACHE_PBB_IQ2000BF
369 #if defined DEFINE_SWITCH || defined FAST_P
370 /* In the switch case FAST_P is a constant, allowing several optimizations
371 in any called inline functions. */
372 vpc = iq2000bf_pbb_begin (current_cpu, FAST_P);
373 #else
374 #if 0 /* cgen engine can't handle dynamic fast/full switching yet. */
375 vpc = iq2000bf_pbb_begin (current_cpu, STATE_RUN_FAST_P (CPU_STATE (current_cpu)));
376 #else
377 vpc = iq2000bf_pbb_begin (current_cpu, 0);
378 #endif
379 #endif
380 #endif
381 }
382
383 #undef FLD
384 }
385 NEXT (vpc);
386
387 CASE (sem, INSN_ADD) : /* add $rd,$rs,$rt */
388 {
389 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
390 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
391 #define FLD(f) abuf->fields.sfmt_mrgb.f
392 int UNUSED written = 0;
393 IADDR UNUSED pc = abuf->addr;
394 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
395
396 {
397 SI opval = ADDSI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)));
398 SET_H_GR (FLD (f_rd), opval);
399 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
400 }
401
402 #undef FLD
403 }
404 NEXT (vpc);
405
406 CASE (sem, INSN_ADDI) : /* addi $rt,$rs,$lo16 */
407 {
408 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
409 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
410 #define FLD(f) abuf->fields.sfmt_addi.f
411 int UNUSED written = 0;
412 IADDR UNUSED pc = abuf->addr;
413 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
414
415 {
416 SI opval = ADDSI (GET_H_GR (FLD (f_rs)), EXTHISI (TRUNCSIHI (FLD (f_imm))));
417 SET_H_GR (FLD (f_rt), opval);
418 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
419 }
420
421 #undef FLD
422 }
423 NEXT (vpc);
424
425 CASE (sem, INSN_ADDIU) : /* addiu $rt,$rs,$lo16 */
426 {
427 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
428 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
429 #define FLD(f) abuf->fields.sfmt_addi.f
430 int UNUSED written = 0;
431 IADDR UNUSED pc = abuf->addr;
432 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
433
434 {
435 SI opval = ADDSI (GET_H_GR (FLD (f_rs)), EXTHISI (TRUNCSIHI (FLD (f_imm))));
436 SET_H_GR (FLD (f_rt), opval);
437 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
438 }
439
440 #undef FLD
441 }
442 NEXT (vpc);
443
444 CASE (sem, INSN_ADDU) : /* addu $rd,$rs,$rt */
445 {
446 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
447 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
448 #define FLD(f) abuf->fields.sfmt_mrgb.f
449 int UNUSED written = 0;
450 IADDR UNUSED pc = abuf->addr;
451 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
452
453 {
454 SI opval = ADDSI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)));
455 SET_H_GR (FLD (f_rd), opval);
456 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
457 }
458
459 #undef FLD
460 }
461 NEXT (vpc);
462
463 CASE (sem, INSN_ADO16) : /* ado16 $rd,$rs,$rt */
464 {
465 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
466 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
467 #define FLD(f) abuf->fields.sfmt_mrgb.f
468 int UNUSED written = 0;
469 IADDR UNUSED pc = abuf->addr;
470 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
471
472 {
473 HI tmp_high;
474 HI tmp_low;
475 tmp_low = ADDHI (ANDHI (GET_H_GR (FLD (f_rs)), 65535), ANDHI (GET_H_GR (FLD (f_rt)), 65535));
476 tmp_high = ADDHI (SRLSI (GET_H_GR (FLD (f_rs)), 16), SRLSI (GET_H_GR (FLD (f_rt)), 16));
477 {
478 SI opval = ORSI (SLLSI (tmp_high, 16), tmp_low);
479 SET_H_GR (FLD (f_rd), opval);
480 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
481 }
482 }
483
484 #undef FLD
485 }
486 NEXT (vpc);
487
488 CASE (sem, INSN_AND) : /* and $rd,$rs,$rt */
489 {
490 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
491 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
492 #define FLD(f) abuf->fields.sfmt_mrgb.f
493 int UNUSED written = 0;
494 IADDR UNUSED pc = abuf->addr;
495 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
496
497 {
498 SI opval = ANDSI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)));
499 SET_H_GR (FLD (f_rd), opval);
500 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
501 }
502
503 #undef FLD
504 }
505 NEXT (vpc);
506
507 CASE (sem, INSN_ANDI) : /* andi $rt,$rs,$lo16 */
508 {
509 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
510 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
511 #define FLD(f) abuf->fields.sfmt_addi.f
512 int UNUSED written = 0;
513 IADDR UNUSED pc = abuf->addr;
514 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
515
516 {
517 SI opval = ANDSI (GET_H_GR (FLD (f_rs)), ZEXTSISI (FLD (f_imm)));
518 SET_H_GR (FLD (f_rt), opval);
519 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
520 }
521
522 #undef FLD
523 }
524 NEXT (vpc);
525
526 CASE (sem, INSN_ANDOI) : /* andoi $rt,$rs,$lo16 */
527 {
528 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
529 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
530 #define FLD(f) abuf->fields.sfmt_addi.f
531 int UNUSED written = 0;
532 IADDR UNUSED pc = abuf->addr;
533 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
534
535 {
536 SI opval = ANDSI (GET_H_GR (FLD (f_rs)), ORSI (0xffff0000, EXTHISI (TRUNCSIHI (FLD (f_imm)))));
537 SET_H_GR (FLD (f_rt), opval);
538 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
539 }
540
541 #undef FLD
542 }
543 NEXT (vpc);
544
545 CASE (sem, INSN_NOR) : /* nor $rd,$rs,$rt */
546 {
547 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
548 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
549 #define FLD(f) abuf->fields.sfmt_mrgb.f
550 int UNUSED written = 0;
551 IADDR UNUSED pc = abuf->addr;
552 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
553
554 {
555 SI opval = INVSI (ORSI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt))));
556 SET_H_GR (FLD (f_rd), opval);
557 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
558 }
559
560 #undef FLD
561 }
562 NEXT (vpc);
563
564 CASE (sem, INSN_OR) : /* or $rd,$rs,$rt */
565 {
566 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
567 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
568 #define FLD(f) abuf->fields.sfmt_mrgb.f
569 int UNUSED written = 0;
570 IADDR UNUSED pc = abuf->addr;
571 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
572
573 {
574 SI opval = ORSI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)));
575 SET_H_GR (FLD (f_rd), opval);
576 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
577 }
578
579 #undef FLD
580 }
581 NEXT (vpc);
582
583 CASE (sem, INSN_ORI) : /* ori $rt,$rs,$lo16 */
584 {
585 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
586 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
587 #define FLD(f) abuf->fields.sfmt_addi.f
588 int UNUSED written = 0;
589 IADDR UNUSED pc = abuf->addr;
590 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
591
592 {
593 SI opval = ORSI (GET_H_GR (FLD (f_rs)), ZEXTSISI (FLD (f_imm)));
594 SET_H_GR (FLD (f_rt), opval);
595 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
596 }
597
598 #undef FLD
599 }
600 NEXT (vpc);
601
602 CASE (sem, INSN_RAM) : /* ram $rd,$rt,$shamt,$maskl,$maskr */
603 {
604 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
605 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
606 #define FLD(f) abuf->fields.sfmt_ram.f
607 int UNUSED written = 0;
608 IADDR UNUSED pc = abuf->addr;
609 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
610
611 {
612 {
613 SI opval = RORSI (GET_H_GR (FLD (f_rt)), FLD (f_shamt));
614 SET_H_GR (FLD (f_rd), opval);
615 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
616 }
617 {
618 SI opval = ANDSI (GET_H_GR (FLD (f_rd)), SRLSI (0xffffffff, FLD (f_maskl)));
619 SET_H_GR (FLD (f_rd), opval);
620 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
621 }
622 {
623 SI opval = ANDSI (GET_H_GR (FLD (f_rd)), SLLSI (0xffffffff, FLD (f_rs)));
624 SET_H_GR (FLD (f_rd), opval);
625 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
626 }
627 }
628
629 #undef FLD
630 }
631 NEXT (vpc);
632
633 CASE (sem, INSN_SLL) : /* sll $rd,$rt,$shamt */
634 {
635 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
636 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
637 #define FLD(f) abuf->fields.sfmt_ram.f
638 int UNUSED written = 0;
639 IADDR UNUSED pc = abuf->addr;
640 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
641
642 {
643 SI opval = SLLSI (GET_H_GR (FLD (f_rt)), FLD (f_shamt));
644 SET_H_GR (FLD (f_rd), opval);
645 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
646 }
647
648 #undef FLD
649 }
650 NEXT (vpc);
651
652 CASE (sem, INSN_SLLV) : /* sllv $rd,$rt,$rs */
653 {
654 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
655 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
656 #define FLD(f) abuf->fields.sfmt_mrgb.f
657 int UNUSED written = 0;
658 IADDR UNUSED pc = abuf->addr;
659 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
660
661 {
662 SI opval = SLLSI (GET_H_GR (FLD (f_rt)), ANDSI (GET_H_GR (FLD (f_rs)), 31));
663 SET_H_GR (FLD (f_rd), opval);
664 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
665 }
666
667 #undef FLD
668 }
669 NEXT (vpc);
670
671 CASE (sem, INSN_SLMV) : /* slmv $rd,$rt,$rs,$shamt */
672 {
673 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
674 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
675 #define FLD(f) abuf->fields.sfmt_ram.f
676 int UNUSED written = 0;
677 IADDR UNUSED pc = abuf->addr;
678 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
679
680 {
681 SI opval = ANDSI (SLLSI (GET_H_GR (FLD (f_rt)), FLD (f_shamt)), SRLSI (0xffffffff, GET_H_GR (FLD (f_rs))));
682 SET_H_GR (FLD (f_rd), opval);
683 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
684 }
685
686 #undef FLD
687 }
688 NEXT (vpc);
689
690 CASE (sem, INSN_SLT) : /* slt $rd,$rs,$rt */
691 {
692 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
693 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
694 #define FLD(f) abuf->fields.sfmt_mrgb.f
695 int UNUSED written = 0;
696 IADDR UNUSED pc = abuf->addr;
697 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
698
699 if (LTSI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)))) {
700 {
701 SI opval = 1;
702 SET_H_GR (FLD (f_rd), opval);
703 written |= (1 << 2);
704 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
705 }
706 } else {
707 {
708 SI opval = 0;
709 SET_H_GR (FLD (f_rd), opval);
710 written |= (1 << 2);
711 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
712 }
713 }
714
715 abuf->written = written;
716 #undef FLD
717 }
718 NEXT (vpc);
719
720 CASE (sem, INSN_SLTI) : /* slti $rt,$rs,$imm */
721 {
722 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
723 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
724 #define FLD(f) abuf->fields.sfmt_addi.f
725 int UNUSED written = 0;
726 IADDR UNUSED pc = abuf->addr;
727 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
728
729 if (LTSI (GET_H_GR (FLD (f_rs)), EXTHISI (TRUNCSIHI (FLD (f_imm))))) {
730 {
731 SI opval = 1;
732 SET_H_GR (FLD (f_rt), opval);
733 written |= (1 << 2);
734 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
735 }
736 } else {
737 {
738 SI opval = 0;
739 SET_H_GR (FLD (f_rt), opval);
740 written |= (1 << 2);
741 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
742 }
743 }
744
745 abuf->written = written;
746 #undef FLD
747 }
748 NEXT (vpc);
749
750 CASE (sem, INSN_SLTIU) : /* sltiu $rt,$rs,$imm */
751 {
752 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
753 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
754 #define FLD(f) abuf->fields.sfmt_addi.f
755 int UNUSED written = 0;
756 IADDR UNUSED pc = abuf->addr;
757 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
758
759 if (LTUSI (GET_H_GR (FLD (f_rs)), EXTHISI (TRUNCSIHI (FLD (f_imm))))) {
760 {
761 SI opval = 1;
762 SET_H_GR (FLD (f_rt), opval);
763 written |= (1 << 2);
764 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
765 }
766 } else {
767 {
768 SI opval = 0;
769 SET_H_GR (FLD (f_rt), opval);
770 written |= (1 << 2);
771 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
772 }
773 }
774
775 abuf->written = written;
776 #undef FLD
777 }
778 NEXT (vpc);
779
780 CASE (sem, INSN_SLTU) : /* sltu $rd,$rs,$rt */
781 {
782 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
783 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
784 #define FLD(f) abuf->fields.sfmt_mrgb.f
785 int UNUSED written = 0;
786 IADDR UNUSED pc = abuf->addr;
787 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
788
789 if (LTUSI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)))) {
790 {
791 SI opval = 1;
792 SET_H_GR (FLD (f_rd), opval);
793 written |= (1 << 2);
794 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
795 }
796 } else {
797 {
798 SI opval = 0;
799 SET_H_GR (FLD (f_rd), opval);
800 written |= (1 << 2);
801 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
802 }
803 }
804
805 abuf->written = written;
806 #undef FLD
807 }
808 NEXT (vpc);
809
810 CASE (sem, INSN_SRA) : /* sra $rd,$rt,$shamt */
811 {
812 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
813 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
814 #define FLD(f) abuf->fields.sfmt_ram.f
815 int UNUSED written = 0;
816 IADDR UNUSED pc = abuf->addr;
817 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
818
819 {
820 SI opval = SRASI (GET_H_GR (FLD (f_rt)), FLD (f_shamt));
821 SET_H_GR (FLD (f_rd), opval);
822 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
823 }
824
825 #undef FLD
826 }
827 NEXT (vpc);
828
829 CASE (sem, INSN_SRAV) : /* srav $rd,$rt,$rs */
830 {
831 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
832 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
833 #define FLD(f) abuf->fields.sfmt_mrgb.f
834 int UNUSED written = 0;
835 IADDR UNUSED pc = abuf->addr;
836 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
837
838 {
839 SI opval = SRASI (GET_H_GR (FLD (f_rt)), ANDSI (GET_H_GR (FLD (f_rs)), 31));
840 SET_H_GR (FLD (f_rd), opval);
841 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
842 }
843
844 #undef FLD
845 }
846 NEXT (vpc);
847
848 CASE (sem, INSN_SRL) : /* srl $rd,$rt,$shamt */
849 {
850 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
851 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
852 #define FLD(f) abuf->fields.sfmt_ram.f
853 int UNUSED written = 0;
854 IADDR UNUSED pc = abuf->addr;
855 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
856
857 {
858 SI opval = SRLSI (GET_H_GR (FLD (f_rt)), FLD (f_shamt));
859 SET_H_GR (FLD (f_rd), opval);
860 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
861 }
862
863 #undef FLD
864 }
865 NEXT (vpc);
866
867 CASE (sem, INSN_SRLV) : /* srlv $rd,$rt,$rs */
868 {
869 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
870 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
871 #define FLD(f) abuf->fields.sfmt_mrgb.f
872 int UNUSED written = 0;
873 IADDR UNUSED pc = abuf->addr;
874 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
875
876 {
877 SI opval = SRLSI (GET_H_GR (FLD (f_rt)), ANDSI (GET_H_GR (FLD (f_rs)), 31));
878 SET_H_GR (FLD (f_rd), opval);
879 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
880 }
881
882 #undef FLD
883 }
884 NEXT (vpc);
885
886 CASE (sem, INSN_SRMV) : /* srmv $rd,$rt,$rs,$shamt */
887 {
888 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
889 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
890 #define FLD(f) abuf->fields.sfmt_ram.f
891 int UNUSED written = 0;
892 IADDR UNUSED pc = abuf->addr;
893 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
894
895 {
896 SI opval = ANDSI (SRLSI (GET_H_GR (FLD (f_rt)), FLD (f_shamt)), SLLSI (0xffffffff, GET_H_GR (FLD (f_rs))));
897 SET_H_GR (FLD (f_rd), opval);
898 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
899 }
900
901 #undef FLD
902 }
903 NEXT (vpc);
904
905 CASE (sem, INSN_SUB) : /* sub $rd,$rs,$rt */
906 {
907 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
908 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
909 #define FLD(f) abuf->fields.sfmt_mrgb.f
910 int UNUSED written = 0;
911 IADDR UNUSED pc = abuf->addr;
912 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
913
914 {
915 SI opval = SUBSI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)));
916 SET_H_GR (FLD (f_rd), opval);
917 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
918 }
919
920 #undef FLD
921 }
922 NEXT (vpc);
923
924 CASE (sem, INSN_SUBU) : /* subu $rd,$rs,$rt */
925 {
926 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
927 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
928 #define FLD(f) abuf->fields.sfmt_mrgb.f
929 int UNUSED written = 0;
930 IADDR UNUSED pc = abuf->addr;
931 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
932
933 {
934 SI opval = SUBSI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)));
935 SET_H_GR (FLD (f_rd), opval);
936 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
937 }
938
939 #undef FLD
940 }
941 NEXT (vpc);
942
943 CASE (sem, INSN_XOR) : /* xor $rd,$rs,$rt */
944 {
945 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
946 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
947 #define FLD(f) abuf->fields.sfmt_mrgb.f
948 int UNUSED written = 0;
949 IADDR UNUSED pc = abuf->addr;
950 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
951
952 {
953 SI opval = XORSI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)));
954 SET_H_GR (FLD (f_rd), opval);
955 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
956 }
957
958 #undef FLD
959 }
960 NEXT (vpc);
961
962 CASE (sem, INSN_XORI) : /* xori $rt,$rs,$lo16 */
963 {
964 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
965 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
966 #define FLD(f) abuf->fields.sfmt_addi.f
967 int UNUSED written = 0;
968 IADDR UNUSED pc = abuf->addr;
969 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
970
971 {
972 SI opval = XORSI (GET_H_GR (FLD (f_rs)), ZEXTSISI (FLD (f_imm)));
973 SET_H_GR (FLD (f_rt), opval);
974 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
975 }
976
977 #undef FLD
978 }
979 NEXT (vpc);
980
981 CASE (sem, INSN_BBI) : /* bbi $rs($bitnum),$offset */
982 {
983 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
984 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
985 #define FLD(f) abuf->fields.sfmt_bbi.f
986 int UNUSED written = 0;
987 IADDR UNUSED pc = abuf->addr;
988 SEM_BRANCH_INIT
989 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
990
991 if (ANDSI (GET_H_GR (FLD (f_rs)), SLLSI (1, FLD (f_rt)))) {
992 {
993 {
994 USI opval = FLD (i_offset);
995 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
996 written |= (1 << 3);
997 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
998 }
999 }
1000 }
1001
1002 abuf->written = written;
1003 SEM_BRANCH_FINI (vpc);
1004 #undef FLD
1005 }
1006 NEXT (vpc);
1007
1008 CASE (sem, INSN_BBIN) : /* bbin $rs($bitnum),$offset */
1009 {
1010 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1011 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1012 #define FLD(f) abuf->fields.sfmt_bbi.f
1013 int UNUSED written = 0;
1014 IADDR UNUSED pc = abuf->addr;
1015 SEM_BRANCH_INIT
1016 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1017
1018 if (NOTSI (ANDSI (GET_H_GR (FLD (f_rs)), SLLSI (1, FLD (f_rt))))) {
1019 {
1020 {
1021 USI opval = FLD (i_offset);
1022 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1023 written |= (1 << 3);
1024 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1025 }
1026 }
1027 }
1028
1029 abuf->written = written;
1030 SEM_BRANCH_FINI (vpc);
1031 #undef FLD
1032 }
1033 NEXT (vpc);
1034
1035 CASE (sem, INSN_BBV) : /* bbv $rs,$rt,$offset */
1036 {
1037 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1038 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1039 #define FLD(f) abuf->fields.sfmt_bbi.f
1040 int UNUSED written = 0;
1041 IADDR UNUSED pc = abuf->addr;
1042 SEM_BRANCH_INIT
1043 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1044
1045 if (ANDSI (GET_H_GR (FLD (f_rs)), SLLSI (1, ANDSI (GET_H_GR (FLD (f_rt)), 31)))) {
1046 {
1047 {
1048 USI opval = FLD (i_offset);
1049 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1050 written |= (1 << 3);
1051 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1052 }
1053 }
1054 }
1055
1056 abuf->written = written;
1057 SEM_BRANCH_FINI (vpc);
1058 #undef FLD
1059 }
1060 NEXT (vpc);
1061
1062 CASE (sem, INSN_BBVN) : /* bbvn $rs,$rt,$offset */
1063 {
1064 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1065 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1066 #define FLD(f) abuf->fields.sfmt_bbi.f
1067 int UNUSED written = 0;
1068 IADDR UNUSED pc = abuf->addr;
1069 SEM_BRANCH_INIT
1070 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1071
1072 if (NOTSI (ANDSI (GET_H_GR (FLD (f_rs)), SLLSI (1, ANDSI (GET_H_GR (FLD (f_rt)), 31))))) {
1073 {
1074 {
1075 USI opval = FLD (i_offset);
1076 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1077 written |= (1 << 3);
1078 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1079 }
1080 }
1081 }
1082
1083 abuf->written = written;
1084 SEM_BRANCH_FINI (vpc);
1085 #undef FLD
1086 }
1087 NEXT (vpc);
1088
1089 CASE (sem, INSN_BEQ) : /* beq $rs,$rt,$offset */
1090 {
1091 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1092 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1093 #define FLD(f) abuf->fields.sfmt_bbi.f
1094 int UNUSED written = 0;
1095 IADDR UNUSED pc = abuf->addr;
1096 SEM_BRANCH_INIT
1097 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1098
1099 if (EQSI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)))) {
1100 {
1101 {
1102 USI opval = FLD (i_offset);
1103 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1104 written |= (1 << 3);
1105 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1106 }
1107 }
1108 }
1109
1110 abuf->written = written;
1111 SEM_BRANCH_FINI (vpc);
1112 #undef FLD
1113 }
1114 NEXT (vpc);
1115
1116 CASE (sem, INSN_BEQL) : /* beql $rs,$rt,$offset */
1117 {
1118 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1119 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1120 #define FLD(f) abuf->fields.sfmt_bbi.f
1121 int UNUSED written = 0;
1122 IADDR UNUSED pc = abuf->addr;
1123 SEM_BRANCH_INIT
1124 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1125
1126 if (EQSI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)))) {
1127 {
1128 {
1129 USI opval = FLD (i_offset);
1130 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1131 written |= (1 << 3);
1132 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1133 }
1134 }
1135 } else {
1136 if (1)
1137 SEM_SKIP_INSN (current_cpu, sem_arg, vpc);
1138 }
1139
1140 abuf->written = written;
1141 SEM_BRANCH_FINI (vpc);
1142 #undef FLD
1143 }
1144 NEXT (vpc);
1145
1146 CASE (sem, INSN_BGEZ) : /* bgez $rs,$offset */
1147 {
1148 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1149 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1150 #define FLD(f) abuf->fields.sfmt_bbi.f
1151 int UNUSED written = 0;
1152 IADDR UNUSED pc = abuf->addr;
1153 SEM_BRANCH_INIT
1154 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1155
1156 if (GESI (GET_H_GR (FLD (f_rs)), 0)) {
1157 {
1158 {
1159 USI opval = FLD (i_offset);
1160 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1161 written |= (1 << 2);
1162 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1163 }
1164 }
1165 }
1166
1167 abuf->written = written;
1168 SEM_BRANCH_FINI (vpc);
1169 #undef FLD
1170 }
1171 NEXT (vpc);
1172
1173 CASE (sem, INSN_BGEZAL) : /* bgezal $rs,$offset */
1174 {
1175 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1176 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1177 #define FLD(f) abuf->fields.sfmt_bbi.f
1178 int UNUSED written = 0;
1179 IADDR UNUSED pc = abuf->addr;
1180 SEM_BRANCH_INIT
1181 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1182
1183 if (GESI (GET_H_GR (FLD (f_rs)), 0)) {
1184 {
1185 {
1186 SI opval = ADDSI (pc, 8);
1187 SET_H_GR (((UINT) 31), opval);
1188 written |= (1 << 3);
1189 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1190 }
1191 {
1192 {
1193 USI opval = FLD (i_offset);
1194 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1195 written |= (1 << 4);
1196 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1197 }
1198 }
1199 }
1200 }
1201
1202 abuf->written = written;
1203 SEM_BRANCH_FINI (vpc);
1204 #undef FLD
1205 }
1206 NEXT (vpc);
1207
1208 CASE (sem, INSN_BGEZALL) : /* bgezall $rs,$offset */
1209 {
1210 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1211 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1212 #define FLD(f) abuf->fields.sfmt_bbi.f
1213 int UNUSED written = 0;
1214 IADDR UNUSED pc = abuf->addr;
1215 SEM_BRANCH_INIT
1216 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1217
1218 if (GESI (GET_H_GR (FLD (f_rs)), 0)) {
1219 {
1220 {
1221 SI opval = ADDSI (pc, 8);
1222 SET_H_GR (((UINT) 31), opval);
1223 written |= (1 << 3);
1224 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1225 }
1226 {
1227 {
1228 USI opval = FLD (i_offset);
1229 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1230 written |= (1 << 4);
1231 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1232 }
1233 }
1234 }
1235 } else {
1236 if (1)
1237 SEM_SKIP_INSN (current_cpu, sem_arg, vpc);
1238 }
1239
1240 abuf->written = written;
1241 SEM_BRANCH_FINI (vpc);
1242 #undef FLD
1243 }
1244 NEXT (vpc);
1245
1246 CASE (sem, INSN_BGEZL) : /* bgezl $rs,$offset */
1247 {
1248 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1249 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1250 #define FLD(f) abuf->fields.sfmt_bbi.f
1251 int UNUSED written = 0;
1252 IADDR UNUSED pc = abuf->addr;
1253 SEM_BRANCH_INIT
1254 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1255
1256 if (GESI (GET_H_GR (FLD (f_rs)), 0)) {
1257 {
1258 {
1259 USI opval = FLD (i_offset);
1260 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1261 written |= (1 << 2);
1262 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1263 }
1264 }
1265 } else {
1266 if (1)
1267 SEM_SKIP_INSN (current_cpu, sem_arg, vpc);
1268 }
1269
1270 abuf->written = written;
1271 SEM_BRANCH_FINI (vpc);
1272 #undef FLD
1273 }
1274 NEXT (vpc);
1275
1276 CASE (sem, INSN_BLTZ) : /* bltz $rs,$offset */
1277 {
1278 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1279 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1280 #define FLD(f) abuf->fields.sfmt_bbi.f
1281 int UNUSED written = 0;
1282 IADDR UNUSED pc = abuf->addr;
1283 SEM_BRANCH_INIT
1284 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1285
1286 if (LTSI (GET_H_GR (FLD (f_rs)), 0)) {
1287 {
1288 {
1289 USI opval = FLD (i_offset);
1290 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1291 written |= (1 << 2);
1292 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1293 }
1294 }
1295 }
1296
1297 abuf->written = written;
1298 SEM_BRANCH_FINI (vpc);
1299 #undef FLD
1300 }
1301 NEXT (vpc);
1302
1303 CASE (sem, INSN_BLTZL) : /* bltzl $rs,$offset */
1304 {
1305 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1306 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1307 #define FLD(f) abuf->fields.sfmt_bbi.f
1308 int UNUSED written = 0;
1309 IADDR UNUSED pc = abuf->addr;
1310 SEM_BRANCH_INIT
1311 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1312
1313 if (LTSI (GET_H_GR (FLD (f_rs)), 0)) {
1314 {
1315 {
1316 USI opval = FLD (i_offset);
1317 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1318 written |= (1 << 2);
1319 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1320 }
1321 }
1322 } else {
1323 if (1)
1324 SEM_SKIP_INSN (current_cpu, sem_arg, vpc);
1325 }
1326
1327 abuf->written = written;
1328 SEM_BRANCH_FINI (vpc);
1329 #undef FLD
1330 }
1331 NEXT (vpc);
1332
1333 CASE (sem, INSN_BLTZAL) : /* bltzal $rs,$offset */
1334 {
1335 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1336 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1337 #define FLD(f) abuf->fields.sfmt_bbi.f
1338 int UNUSED written = 0;
1339 IADDR UNUSED pc = abuf->addr;
1340 SEM_BRANCH_INIT
1341 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1342
1343 if (LTSI (GET_H_GR (FLD (f_rs)), 0)) {
1344 {
1345 {
1346 SI opval = ADDSI (pc, 8);
1347 SET_H_GR (((UINT) 31), opval);
1348 written |= (1 << 3);
1349 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1350 }
1351 {
1352 {
1353 USI opval = FLD (i_offset);
1354 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1355 written |= (1 << 4);
1356 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1357 }
1358 }
1359 }
1360 }
1361
1362 abuf->written = written;
1363 SEM_BRANCH_FINI (vpc);
1364 #undef FLD
1365 }
1366 NEXT (vpc);
1367
1368 CASE (sem, INSN_BLTZALL) : /* bltzall $rs,$offset */
1369 {
1370 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1371 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1372 #define FLD(f) abuf->fields.sfmt_bbi.f
1373 int UNUSED written = 0;
1374 IADDR UNUSED pc = abuf->addr;
1375 SEM_BRANCH_INIT
1376 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1377
1378 if (LTSI (GET_H_GR (FLD (f_rs)), 0)) {
1379 {
1380 {
1381 SI opval = ADDSI (pc, 8);
1382 SET_H_GR (((UINT) 31), opval);
1383 written |= (1 << 3);
1384 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1385 }
1386 {
1387 {
1388 USI opval = FLD (i_offset);
1389 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1390 written |= (1 << 4);
1391 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1392 }
1393 }
1394 }
1395 } else {
1396 if (1)
1397 SEM_SKIP_INSN (current_cpu, sem_arg, vpc);
1398 }
1399
1400 abuf->written = written;
1401 SEM_BRANCH_FINI (vpc);
1402 #undef FLD
1403 }
1404 NEXT (vpc);
1405
1406 CASE (sem, INSN_BMB0) : /* bmb0 $rs,$rt,$offset */
1407 {
1408 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1409 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1410 #define FLD(f) abuf->fields.sfmt_bbi.f
1411 int UNUSED written = 0;
1412 IADDR UNUSED pc = abuf->addr;
1413 SEM_BRANCH_INIT
1414 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1415
1416 if (EQSI (ANDSI (GET_H_GR (FLD (f_rs)), 255), ANDSI (GET_H_GR (FLD (f_rt)), 255))) {
1417 {
1418 {
1419 USI opval = FLD (i_offset);
1420 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1421 written |= (1 << 3);
1422 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1423 }
1424 }
1425 }
1426
1427 abuf->written = written;
1428 SEM_BRANCH_FINI (vpc);
1429 #undef FLD
1430 }
1431 NEXT (vpc);
1432
1433 CASE (sem, INSN_BMB1) : /* bmb1 $rs,$rt,$offset */
1434 {
1435 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1436 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1437 #define FLD(f) abuf->fields.sfmt_bbi.f
1438 int UNUSED written = 0;
1439 IADDR UNUSED pc = abuf->addr;
1440 SEM_BRANCH_INIT
1441 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1442
1443 if (EQSI (ANDSI (GET_H_GR (FLD (f_rs)), 65280), ANDSI (GET_H_GR (FLD (f_rt)), 65280))) {
1444 {
1445 {
1446 USI opval = FLD (i_offset);
1447 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1448 written |= (1 << 3);
1449 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1450 }
1451 }
1452 }
1453
1454 abuf->written = written;
1455 SEM_BRANCH_FINI (vpc);
1456 #undef FLD
1457 }
1458 NEXT (vpc);
1459
1460 CASE (sem, INSN_BMB2) : /* bmb2 $rs,$rt,$offset */
1461 {
1462 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1463 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1464 #define FLD(f) abuf->fields.sfmt_bbi.f
1465 int UNUSED written = 0;
1466 IADDR UNUSED pc = abuf->addr;
1467 SEM_BRANCH_INIT
1468 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1469
1470 if (EQSI (ANDSI (GET_H_GR (FLD (f_rs)), 16711680), ANDSI (GET_H_GR (FLD (f_rt)), 16711680))) {
1471 {
1472 {
1473 USI opval = FLD (i_offset);
1474 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1475 written |= (1 << 3);
1476 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1477 }
1478 }
1479 }
1480
1481 abuf->written = written;
1482 SEM_BRANCH_FINI (vpc);
1483 #undef FLD
1484 }
1485 NEXT (vpc);
1486
1487 CASE (sem, INSN_BMB3) : /* bmb3 $rs,$rt,$offset */
1488 {
1489 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1490 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1491 #define FLD(f) abuf->fields.sfmt_bbi.f
1492 int UNUSED written = 0;
1493 IADDR UNUSED pc = abuf->addr;
1494 SEM_BRANCH_INIT
1495 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1496
1497 if (EQSI (ANDSI (GET_H_GR (FLD (f_rs)), 0xff000000), ANDSI (GET_H_GR (FLD (f_rt)), 0xff000000))) {
1498 {
1499 {
1500 USI opval = FLD (i_offset);
1501 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1502 written |= (1 << 3);
1503 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1504 }
1505 }
1506 }
1507
1508 abuf->written = written;
1509 SEM_BRANCH_FINI (vpc);
1510 #undef FLD
1511 }
1512 NEXT (vpc);
1513
1514 CASE (sem, INSN_BNE) : /* bne $rs,$rt,$offset */
1515 {
1516 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1517 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1518 #define FLD(f) abuf->fields.sfmt_bbi.f
1519 int UNUSED written = 0;
1520 IADDR UNUSED pc = abuf->addr;
1521 SEM_BRANCH_INIT
1522 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1523
1524 if (NESI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)))) {
1525 {
1526 {
1527 USI opval = FLD (i_offset);
1528 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1529 written |= (1 << 3);
1530 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1531 }
1532 }
1533 }
1534
1535 abuf->written = written;
1536 SEM_BRANCH_FINI (vpc);
1537 #undef FLD
1538 }
1539 NEXT (vpc);
1540
1541 CASE (sem, INSN_BNEL) : /* bnel $rs,$rt,$offset */
1542 {
1543 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1544 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1545 #define FLD(f) abuf->fields.sfmt_bbi.f
1546 int UNUSED written = 0;
1547 IADDR UNUSED pc = abuf->addr;
1548 SEM_BRANCH_INIT
1549 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1550
1551 if (NESI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)))) {
1552 {
1553 {
1554 USI opval = FLD (i_offset);
1555 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1556 written |= (1 << 3);
1557 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1558 }
1559 }
1560 } else {
1561 if (1)
1562 SEM_SKIP_INSN (current_cpu, sem_arg, vpc);
1563 }
1564
1565 abuf->written = written;
1566 SEM_BRANCH_FINI (vpc);
1567 #undef FLD
1568 }
1569 NEXT (vpc);
1570
1571 CASE (sem, INSN_JALR) : /* jalr $rd,$rs */
1572 {
1573 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1574 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1575 #define FLD(f) abuf->fields.sfmt_mrgb.f
1576 int UNUSED written = 0;
1577 IADDR UNUSED pc = abuf->addr;
1578 SEM_BRANCH_INIT
1579 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1580
1581 {
1582 {
1583 {
1584 SI opval = ADDSI (pc, 8);
1585 SET_H_GR (FLD (f_rd), opval);
1586 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1587 }
1588 {
1589 USI opval = GET_H_GR (FLD (f_rs));
1590 SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
1591 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1592 }
1593 }
1594 }
1595
1596 SEM_BRANCH_FINI (vpc);
1597 #undef FLD
1598 }
1599 NEXT (vpc);
1600
1601 CASE (sem, INSN_JR) : /* jr $rs */
1602 {
1603 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1604 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1605 #define FLD(f) abuf->fields.sfmt_bbi.f
1606 int UNUSED written = 0;
1607 IADDR UNUSED pc = abuf->addr;
1608 SEM_BRANCH_INIT
1609 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1610
1611 {
1612 {
1613 USI opval = GET_H_GR (FLD (f_rs));
1614 SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
1615 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1616 }
1617 }
1618
1619 SEM_BRANCH_FINI (vpc);
1620 #undef FLD
1621 }
1622 NEXT (vpc);
1623
1624 CASE (sem, INSN_LB) : /* lb $rt,$lo16($base) */
1625 {
1626 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1627 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1628 #define FLD(f) abuf->fields.sfmt_addi.f
1629 int UNUSED written = 0;
1630 IADDR UNUSED pc = abuf->addr;
1631 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1632
1633 {
1634 SI opval = EXTQISI (GETMEMQI (current_cpu, pc, ADDSI (GET_H_GR (FLD (f_rs)), EXTHISI (TRUNCSIHI (FLD (f_imm))))));
1635 SET_H_GR (FLD (f_rt), opval);
1636 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1637 }
1638
1639 #undef FLD
1640 }
1641 NEXT (vpc);
1642
1643 CASE (sem, INSN_LBU) : /* lbu $rt,$lo16($base) */
1644 {
1645 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1646 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1647 #define FLD(f) abuf->fields.sfmt_addi.f
1648 int UNUSED written = 0;
1649 IADDR UNUSED pc = abuf->addr;
1650 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1651
1652 {
1653 SI opval = ZEXTQISI (GETMEMQI (current_cpu, pc, ADDSI (GET_H_GR (FLD (f_rs)), EXTHISI (TRUNCSIHI (FLD (f_imm))))));
1654 SET_H_GR (FLD (f_rt), opval);
1655 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1656 }
1657
1658 #undef FLD
1659 }
1660 NEXT (vpc);
1661
1662 CASE (sem, INSN_LH) : /* lh $rt,$lo16($base) */
1663 {
1664 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1665 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1666 #define FLD(f) abuf->fields.sfmt_addi.f
1667 int UNUSED written = 0;
1668 IADDR UNUSED pc = abuf->addr;
1669 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1670
1671 {
1672 SI opval = EXTHISI (GETMEMHI (current_cpu, pc, ADDSI (GET_H_GR (FLD (f_rs)), EXTHISI (TRUNCSIHI (FLD (f_imm))))));
1673 SET_H_GR (FLD (f_rt), opval);
1674 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1675 }
1676
1677 #undef FLD
1678 }
1679 NEXT (vpc);
1680
1681 CASE (sem, INSN_LHU) : /* lhu $rt,$lo16($base) */
1682 {
1683 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1684 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1685 #define FLD(f) abuf->fields.sfmt_addi.f
1686 int UNUSED written = 0;
1687 IADDR UNUSED pc = abuf->addr;
1688 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1689
1690 {
1691 SI opval = ZEXTHISI (GETMEMHI (current_cpu, pc, ADDSI (GET_H_GR (FLD (f_rs)), EXTHISI (TRUNCSIHI (FLD (f_imm))))));
1692 SET_H_GR (FLD (f_rt), opval);
1693 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1694 }
1695
1696 #undef FLD
1697 }
1698 NEXT (vpc);
1699
1700 CASE (sem, INSN_LUI) : /* lui $rt,$hi16 */
1701 {
1702 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1703 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1704 #define FLD(f) abuf->fields.sfmt_addi.f
1705 int UNUSED written = 0;
1706 IADDR UNUSED pc = abuf->addr;
1707 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1708
1709 {
1710 SI opval = SLLSI (FLD (f_imm), 16);
1711 SET_H_GR (FLD (f_rt), opval);
1712 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1713 }
1714
1715 #undef FLD
1716 }
1717 NEXT (vpc);
1718
1719 CASE (sem, INSN_LW) : /* lw $rt,$lo16($base) */
1720 {
1721 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1722 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1723 #define FLD(f) abuf->fields.sfmt_addi.f
1724 int UNUSED written = 0;
1725 IADDR UNUSED pc = abuf->addr;
1726 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1727
1728 {
1729 SI opval = GETMEMSI (current_cpu, pc, ADDSI (GET_H_GR (FLD (f_rs)), EXTHISI (TRUNCSIHI (FLD (f_imm)))));
1730 SET_H_GR (FLD (f_rt), opval);
1731 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1732 }
1733
1734 #undef FLD
1735 }
1736 NEXT (vpc);
1737
1738 CASE (sem, INSN_SB) : /* sb $rt,$lo16($base) */
1739 {
1740 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1741 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1742 #define FLD(f) abuf->fields.sfmt_addi.f
1743 int UNUSED written = 0;
1744 IADDR UNUSED pc = abuf->addr;
1745 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1746
1747 {
1748 QI opval = ANDQI (GET_H_GR (FLD (f_rt)), 255);
1749 SETMEMQI (current_cpu, pc, ADDSI (GET_H_GR (FLD (f_rs)), EXTHISI (TRUNCSIHI (FLD (f_imm)))), opval);
1750 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
1751 }
1752
1753 #undef FLD
1754 }
1755 NEXT (vpc);
1756
1757 CASE (sem, INSN_SH) : /* sh $rt,$lo16($base) */
1758 {
1759 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1760 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1761 #define FLD(f) abuf->fields.sfmt_addi.f
1762 int UNUSED written = 0;
1763 IADDR UNUSED pc = abuf->addr;
1764 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1765
1766 {
1767 HI opval = ANDHI (GET_H_GR (FLD (f_rt)), 65535);
1768 SETMEMHI (current_cpu, pc, ADDSI (GET_H_GR (FLD (f_rs)), EXTHISI (TRUNCSIHI (FLD (f_imm)))), opval);
1769 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
1770 }
1771
1772 #undef FLD
1773 }
1774 NEXT (vpc);
1775
1776 CASE (sem, INSN_SW) : /* sw $rt,$lo16($base) */
1777 {
1778 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1779 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1780 #define FLD(f) abuf->fields.sfmt_addi.f
1781 int UNUSED written = 0;
1782 IADDR UNUSED pc = abuf->addr;
1783 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1784
1785 {
1786 SI opval = GET_H_GR (FLD (f_rt));
1787 SETMEMSI (current_cpu, pc, ADDSI (GET_H_GR (FLD (f_rs)), EXTHISI (TRUNCSIHI (FLD (f_imm)))), opval);
1788 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
1789 }
1790
1791 #undef FLD
1792 }
1793 NEXT (vpc);
1794
1795 CASE (sem, INSN_BREAK) : /* break */
1796 {
1797 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1798 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1799 #define FLD(f) abuf->fields.fmt_empty.f
1800 int UNUSED written = 0;
1801 IADDR UNUSED pc = abuf->addr;
1802 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1803
1804 do_break (current_cpu, pc);
1805
1806 #undef FLD
1807 }
1808 NEXT (vpc);
1809
1810 CASE (sem, INSN_SYSCALL) : /* syscall */
1811 {
1812 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1813 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1814 #define FLD(f) abuf->fields.fmt_empty.f
1815 int UNUSED written = 0;
1816 IADDR UNUSED pc = abuf->addr;
1817 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1818
1819 do_syscall (current_cpu);
1820
1821 #undef FLD
1822 }
1823 NEXT (vpc);
1824
1825 CASE (sem, INSN_ANDOUI) : /* andoui $rt,$rs,$hi16 */
1826 {
1827 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1828 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1829 #define FLD(f) abuf->fields.sfmt_addi.f
1830 int UNUSED written = 0;
1831 IADDR UNUSED pc = abuf->addr;
1832 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1833
1834 {
1835 SI opval = ANDSI (GET_H_GR (FLD (f_rs)), ORSI (SLLSI (FLD (f_imm), 16), 65535));
1836 SET_H_GR (FLD (f_rt), opval);
1837 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1838 }
1839
1840 #undef FLD
1841 }
1842 NEXT (vpc);
1843
1844 CASE (sem, INSN_ORUI) : /* orui $rt,$rs,$hi16 */
1845 {
1846 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1847 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1848 #define FLD(f) abuf->fields.sfmt_addi.f
1849 int UNUSED written = 0;
1850 IADDR UNUSED pc = abuf->addr;
1851 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1852
1853 {
1854 SI opval = ORSI (GET_H_GR (FLD (f_rs)), SLLSI (FLD (f_imm), 16));
1855 SET_H_GR (FLD (f_rt), opval);
1856 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1857 }
1858
1859 #undef FLD
1860 }
1861 NEXT (vpc);
1862
1863 CASE (sem, INSN_BGTZ) : /* bgtz $rs,$offset */
1864 {
1865 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1866 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1867 #define FLD(f) abuf->fields.sfmt_bbi.f
1868 int UNUSED written = 0;
1869 IADDR UNUSED pc = abuf->addr;
1870 SEM_BRANCH_INIT
1871 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1872
1873 if (GTSI (GET_H_GR (FLD (f_rs)), 0)) {
1874 {
1875 {
1876 USI opval = FLD (i_offset);
1877 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1878 written |= (1 << 2);
1879 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1880 }
1881 }
1882 }
1883
1884 abuf->written = written;
1885 SEM_BRANCH_FINI (vpc);
1886 #undef FLD
1887 }
1888 NEXT (vpc);
1889
1890 CASE (sem, INSN_BGTZL) : /* bgtzl $rs,$offset */
1891 {
1892 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1893 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1894 #define FLD(f) abuf->fields.sfmt_bbi.f
1895 int UNUSED written = 0;
1896 IADDR UNUSED pc = abuf->addr;
1897 SEM_BRANCH_INIT
1898 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1899
1900 if (GTSI (GET_H_GR (FLD (f_rs)), 0)) {
1901 {
1902 {
1903 USI opval = FLD (i_offset);
1904 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1905 written |= (1 << 2);
1906 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1907 }
1908 }
1909 } else {
1910 if (1)
1911 SEM_SKIP_INSN (current_cpu, sem_arg, vpc);
1912 }
1913
1914 abuf->written = written;
1915 SEM_BRANCH_FINI (vpc);
1916 #undef FLD
1917 }
1918 NEXT (vpc);
1919
1920 CASE (sem, INSN_BLEZ) : /* blez $rs,$offset */
1921 {
1922 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1923 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1924 #define FLD(f) abuf->fields.sfmt_bbi.f
1925 int UNUSED written = 0;
1926 IADDR UNUSED pc = abuf->addr;
1927 SEM_BRANCH_INIT
1928 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1929
1930 if (LESI (GET_H_GR (FLD (f_rs)), 0)) {
1931 {
1932 {
1933 USI opval = FLD (i_offset);
1934 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1935 written |= (1 << 2);
1936 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1937 }
1938 }
1939 }
1940
1941 abuf->written = written;
1942 SEM_BRANCH_FINI (vpc);
1943 #undef FLD
1944 }
1945 NEXT (vpc);
1946
1947 CASE (sem, INSN_BLEZL) : /* blezl $rs,$offset */
1948 {
1949 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1950 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1951 #define FLD(f) abuf->fields.sfmt_bbi.f
1952 int UNUSED written = 0;
1953 IADDR UNUSED pc = abuf->addr;
1954 SEM_BRANCH_INIT
1955 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1956
1957 if (LESI (GET_H_GR (FLD (f_rs)), 0)) {
1958 {
1959 {
1960 USI opval = FLD (i_offset);
1961 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1962 written |= (1 << 2);
1963 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1964 }
1965 }
1966 } else {
1967 if (1)
1968 SEM_SKIP_INSN (current_cpu, sem_arg, vpc);
1969 }
1970
1971 abuf->written = written;
1972 SEM_BRANCH_FINI (vpc);
1973 #undef FLD
1974 }
1975 NEXT (vpc);
1976
1977 CASE (sem, INSN_MRGB) : /* mrgb $rd,$rs,$rt,$mask */
1978 {
1979 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1980 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1981 #define FLD(f) abuf->fields.sfmt_mrgb.f
1982 int UNUSED written = 0;
1983 IADDR UNUSED pc = abuf->addr;
1984 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1985
1986 {
1987 SI tmp_temp;
1988 if (NOTSI (ANDSI (FLD (f_mask), SLLSI (1, 0)))) {
1989 tmp_temp = ANDSI (GET_H_GR (FLD (f_rs)), 255);
1990 } else {
1991 tmp_temp = ANDSI (GET_H_GR (FLD (f_rt)), 255);
1992 }
1993 if (NOTSI (ANDSI (FLD (f_mask), SLLSI (1, 1)))) {
1994 tmp_temp = ORSI (tmp_temp, ANDSI (GET_H_GR (FLD (f_rs)), 65280));
1995 } else {
1996 tmp_temp = ORSI (tmp_temp, ANDSI (GET_H_GR (FLD (f_rt)), 65280));
1997 }
1998 if (NOTSI (ANDSI (FLD (f_mask), SLLSI (1, 2)))) {
1999 tmp_temp = ORSI (tmp_temp, ANDSI (GET_H_GR (FLD (f_rs)), 16711680));
2000 } else {
2001 tmp_temp = ORSI (tmp_temp, ANDSI (GET_H_GR (FLD (f_rt)), 16711680));
2002 }
2003 if (NOTSI (ANDSI (FLD (f_mask), SLLSI (1, 3)))) {
2004 tmp_temp = ORSI (tmp_temp, ANDSI (GET_H_GR (FLD (f_rs)), 0xff000000));
2005 } else {
2006 tmp_temp = ORSI (tmp_temp, ANDSI (GET_H_GR (FLD (f_rt)), 0xff000000));
2007 }
2008 {
2009 SI opval = tmp_temp;
2010 SET_H_GR (FLD (f_rd), opval);
2011 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2012 }
2013 }
2014
2015 #undef FLD
2016 }
2017 NEXT (vpc);
2018
2019 CASE (sem, INSN_BCTXT) : /* bctxt $rs,$offset */
2020 {
2021 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2022 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2023 #define FLD(f) abuf->fields.fmt_empty.f
2024 int UNUSED written = 0;
2025 IADDR UNUSED pc = abuf->addr;
2026 SEM_BRANCH_INIT
2027 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2028
2029 ((void) 0); /*nop*/
2030
2031 SEM_BRANCH_FINI (vpc);
2032 #undef FLD
2033 }
2034 NEXT (vpc);
2035
2036 CASE (sem, INSN_BC0F) : /* bc0f $offset */
2037 {
2038 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2039 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2040 #define FLD(f) abuf->fields.fmt_empty.f
2041 int UNUSED written = 0;
2042 IADDR UNUSED pc = abuf->addr;
2043 SEM_BRANCH_INIT
2044 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2045
2046 ((void) 0); /*nop*/
2047
2048 SEM_BRANCH_FINI (vpc);
2049 #undef FLD
2050 }
2051 NEXT (vpc);
2052
2053 CASE (sem, INSN_BC0FL) : /* bc0fl $offset */
2054 {
2055 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2056 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2057 #define FLD(f) abuf->fields.fmt_empty.f
2058 int UNUSED written = 0;
2059 IADDR UNUSED pc = abuf->addr;
2060 SEM_BRANCH_INIT
2061 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2062
2063 ((void) 0); /*nop*/
2064
2065 SEM_BRANCH_FINI (vpc);
2066 #undef FLD
2067 }
2068 NEXT (vpc);
2069
2070 CASE (sem, INSN_BC3F) : /* bc3f $offset */
2071 {
2072 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2073 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2074 #define FLD(f) abuf->fields.fmt_empty.f
2075 int UNUSED written = 0;
2076 IADDR UNUSED pc = abuf->addr;
2077 SEM_BRANCH_INIT
2078 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2079
2080 ((void) 0); /*nop*/
2081
2082 SEM_BRANCH_FINI (vpc);
2083 #undef FLD
2084 }
2085 NEXT (vpc);
2086
2087 CASE (sem, INSN_BC3FL) : /* bc3fl $offset */
2088 {
2089 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2090 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2091 #define FLD(f) abuf->fields.fmt_empty.f
2092 int UNUSED written = 0;
2093 IADDR UNUSED pc = abuf->addr;
2094 SEM_BRANCH_INIT
2095 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2096
2097 ((void) 0); /*nop*/
2098
2099 SEM_BRANCH_FINI (vpc);
2100 #undef FLD
2101 }
2102 NEXT (vpc);
2103
2104 CASE (sem, INSN_BC0T) : /* bc0t $offset */
2105 {
2106 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2107 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2108 #define FLD(f) abuf->fields.fmt_empty.f
2109 int UNUSED written = 0;
2110 IADDR UNUSED pc = abuf->addr;
2111 SEM_BRANCH_INIT
2112 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2113
2114 ((void) 0); /*nop*/
2115
2116 SEM_BRANCH_FINI (vpc);
2117 #undef FLD
2118 }
2119 NEXT (vpc);
2120
2121 CASE (sem, INSN_BC0TL) : /* bc0tl $offset */
2122 {
2123 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2124 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2125 #define FLD(f) abuf->fields.fmt_empty.f
2126 int UNUSED written = 0;
2127 IADDR UNUSED pc = abuf->addr;
2128 SEM_BRANCH_INIT
2129 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2130
2131 ((void) 0); /*nop*/
2132
2133 SEM_BRANCH_FINI (vpc);
2134 #undef FLD
2135 }
2136 NEXT (vpc);
2137
2138 CASE (sem, INSN_BC3T) : /* bc3t $offset */
2139 {
2140 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2141 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2142 #define FLD(f) abuf->fields.fmt_empty.f
2143 int UNUSED written = 0;
2144 IADDR UNUSED pc = abuf->addr;
2145 SEM_BRANCH_INIT
2146 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2147
2148 ((void) 0); /*nop*/
2149
2150 SEM_BRANCH_FINI (vpc);
2151 #undef FLD
2152 }
2153 NEXT (vpc);
2154
2155 CASE (sem, INSN_BC3TL) : /* bc3tl $offset */
2156 {
2157 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2158 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2159 #define FLD(f) abuf->fields.fmt_empty.f
2160 int UNUSED written = 0;
2161 IADDR UNUSED pc = abuf->addr;
2162 SEM_BRANCH_INIT
2163 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2164
2165 ((void) 0); /*nop*/
2166
2167 SEM_BRANCH_FINI (vpc);
2168 #undef FLD
2169 }
2170 NEXT (vpc);
2171
2172 CASE (sem, INSN_CFC0) : /* cfc0 $rt,$rd */
2173 {
2174 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2175 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2176 #define FLD(f) abuf->fields.fmt_empty.f
2177 int UNUSED written = 0;
2178 IADDR UNUSED pc = abuf->addr;
2179 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2180
2181 ((void) 0); /*nop*/
2182
2183 #undef FLD
2184 }
2185 NEXT (vpc);
2186
2187 CASE (sem, INSN_CFC1) : /* cfc1 $rt,$rd */
2188 {
2189 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2190 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2191 #define FLD(f) abuf->fields.fmt_empty.f
2192 int UNUSED written = 0;
2193 IADDR UNUSED pc = abuf->addr;
2194 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2195
2196 ((void) 0); /*nop*/
2197
2198 #undef FLD
2199 }
2200 NEXT (vpc);
2201
2202 CASE (sem, INSN_CFC2) : /* cfc2 $rt,$rd */
2203 {
2204 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2205 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2206 #define FLD(f) abuf->fields.fmt_empty.f
2207 int UNUSED written = 0;
2208 IADDR UNUSED pc = abuf->addr;
2209 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2210
2211 ((void) 0); /*nop*/
2212
2213 #undef FLD
2214 }
2215 NEXT (vpc);
2216
2217 CASE (sem, INSN_CFC3) : /* cfc3 $rt,$rd */
2218 {
2219 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2220 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2221 #define FLD(f) abuf->fields.fmt_empty.f
2222 int UNUSED written = 0;
2223 IADDR UNUSED pc = abuf->addr;
2224 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2225
2226 ((void) 0); /*nop*/
2227
2228 #undef FLD
2229 }
2230 NEXT (vpc);
2231
2232 CASE (sem, INSN_CHKHDR) : /* chkhdr $rd,$rt */
2233 {
2234 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2235 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2236 #define FLD(f) abuf->fields.fmt_empty.f
2237 int UNUSED written = 0;
2238 IADDR UNUSED pc = abuf->addr;
2239 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2240
2241 ((void) 0); /*nop*/
2242
2243 #undef FLD
2244 }
2245 NEXT (vpc);
2246
2247 CASE (sem, INSN_CTC0) : /* ctc0 $rt,$rd */
2248 {
2249 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2250 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2251 #define FLD(f) abuf->fields.fmt_empty.f
2252 int UNUSED written = 0;
2253 IADDR UNUSED pc = abuf->addr;
2254 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2255
2256 ((void) 0); /*nop*/
2257
2258 #undef FLD
2259 }
2260 NEXT (vpc);
2261
2262 CASE (sem, INSN_CTC1) : /* ctc1 $rt,$rd */
2263 {
2264 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2265 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2266 #define FLD(f) abuf->fields.fmt_empty.f
2267 int UNUSED written = 0;
2268 IADDR UNUSED pc = abuf->addr;
2269 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2270
2271 ((void) 0); /*nop*/
2272
2273 #undef FLD
2274 }
2275 NEXT (vpc);
2276
2277 CASE (sem, INSN_CTC2) : /* ctc2 $rt,$rd */
2278 {
2279 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2280 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2281 #define FLD(f) abuf->fields.fmt_empty.f
2282 int UNUSED written = 0;
2283 IADDR UNUSED pc = abuf->addr;
2284 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2285
2286 ((void) 0); /*nop*/
2287
2288 #undef FLD
2289 }
2290 NEXT (vpc);
2291
2292 CASE (sem, INSN_CTC3) : /* ctc3 $rt,$rd */
2293 {
2294 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2295 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2296 #define FLD(f) abuf->fields.fmt_empty.f
2297 int UNUSED written = 0;
2298 IADDR UNUSED pc = abuf->addr;
2299 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2300
2301 ((void) 0); /*nop*/
2302
2303 #undef FLD
2304 }
2305 NEXT (vpc);
2306
2307 CASE (sem, INSN_JCR) : /* jcr $rs */
2308 {
2309 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2310 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2311 #define FLD(f) abuf->fields.fmt_empty.f
2312 int UNUSED written = 0;
2313 IADDR UNUSED pc = abuf->addr;
2314 SEM_BRANCH_INIT
2315 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2316
2317 ((void) 0); /*nop*/
2318
2319 SEM_BRANCH_FINI (vpc);
2320 #undef FLD
2321 }
2322 NEXT (vpc);
2323
2324 CASE (sem, INSN_LUC32) : /* luc32 $rt,$rd */
2325 {
2326 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2327 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2328 #define FLD(f) abuf->fields.fmt_empty.f
2329 int UNUSED written = 0;
2330 IADDR UNUSED pc = abuf->addr;
2331 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2332
2333 ((void) 0); /*nop*/
2334
2335 #undef FLD
2336 }
2337 NEXT (vpc);
2338
2339 CASE (sem, INSN_LUC32L) : /* luc32l $rt,$rd */
2340 {
2341 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2342 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2343 #define FLD(f) abuf->fields.fmt_empty.f
2344 int UNUSED written = 0;
2345 IADDR UNUSED pc = abuf->addr;
2346 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2347
2348 ((void) 0); /*nop*/
2349
2350 #undef FLD
2351 }
2352 NEXT (vpc);
2353
2354 CASE (sem, INSN_LUC64) : /* luc64 $rt,$rd */
2355 {
2356 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2357 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2358 #define FLD(f) abuf->fields.fmt_empty.f
2359 int UNUSED written = 0;
2360 IADDR UNUSED pc = abuf->addr;
2361 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2362
2363 ((void) 0); /*nop*/
2364
2365 #undef FLD
2366 }
2367 NEXT (vpc);
2368
2369 CASE (sem, INSN_LUC64L) : /* luc64l $rt,$rd */
2370 {
2371 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2372 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2373 #define FLD(f) abuf->fields.fmt_empty.f
2374 int UNUSED written = 0;
2375 IADDR UNUSED pc = abuf->addr;
2376 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2377
2378 ((void) 0); /*nop*/
2379
2380 #undef FLD
2381 }
2382 NEXT (vpc);
2383
2384 CASE (sem, INSN_LUK) : /* luk $rt,$rd */
2385 {
2386 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2387 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2388 #define FLD(f) abuf->fields.fmt_empty.f
2389 int UNUSED written = 0;
2390 IADDR UNUSED pc = abuf->addr;
2391 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2392
2393 ((void) 0); /*nop*/
2394
2395 #undef FLD
2396 }
2397 NEXT (vpc);
2398
2399 CASE (sem, INSN_LULCK) : /* lulck $rt */
2400 {
2401 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2402 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2403 #define FLD(f) abuf->fields.fmt_empty.f
2404 int UNUSED written = 0;
2405 IADDR UNUSED pc = abuf->addr;
2406 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2407
2408 ((void) 0); /*nop*/
2409
2410 #undef FLD
2411 }
2412 NEXT (vpc);
2413
2414 CASE (sem, INSN_LUM32) : /* lum32 $rt,$rd */
2415 {
2416 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2417 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2418 #define FLD(f) abuf->fields.fmt_empty.f
2419 int UNUSED written = 0;
2420 IADDR UNUSED pc = abuf->addr;
2421 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2422
2423 ((void) 0); /*nop*/
2424
2425 #undef FLD
2426 }
2427 NEXT (vpc);
2428
2429 CASE (sem, INSN_LUM32L) : /* lum32l $rt,$rd */
2430 {
2431 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2432 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2433 #define FLD(f) abuf->fields.fmt_empty.f
2434 int UNUSED written = 0;
2435 IADDR UNUSED pc = abuf->addr;
2436 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2437
2438 ((void) 0); /*nop*/
2439
2440 #undef FLD
2441 }
2442 NEXT (vpc);
2443
2444 CASE (sem, INSN_LUM64) : /* lum64 $rt,$rd */
2445 {
2446 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2447 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2448 #define FLD(f) abuf->fields.fmt_empty.f
2449 int UNUSED written = 0;
2450 IADDR UNUSED pc = abuf->addr;
2451 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2452
2453 ((void) 0); /*nop*/
2454
2455 #undef FLD
2456 }
2457 NEXT (vpc);
2458
2459 CASE (sem, INSN_LUM64L) : /* lum64l $rt,$rd */
2460 {
2461 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2462 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2463 #define FLD(f) abuf->fields.fmt_empty.f
2464 int UNUSED written = 0;
2465 IADDR UNUSED pc = abuf->addr;
2466 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2467
2468 ((void) 0); /*nop*/
2469
2470 #undef FLD
2471 }
2472 NEXT (vpc);
2473
2474 CASE (sem, INSN_LUR) : /* lur $rt,$rd */
2475 {
2476 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2477 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2478 #define FLD(f) abuf->fields.fmt_empty.f
2479 int UNUSED written = 0;
2480 IADDR UNUSED pc = abuf->addr;
2481 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2482
2483 ((void) 0); /*nop*/
2484
2485 #undef FLD
2486 }
2487 NEXT (vpc);
2488
2489 CASE (sem, INSN_LURL) : /* lurl $rt,$rd */
2490 {
2491 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2492 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2493 #define FLD(f) abuf->fields.fmt_empty.f
2494 int UNUSED written = 0;
2495 IADDR UNUSED pc = abuf->addr;
2496 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2497
2498 ((void) 0); /*nop*/
2499
2500 #undef FLD
2501 }
2502 NEXT (vpc);
2503
2504 CASE (sem, INSN_LUULCK) : /* luulck $rt */
2505 {
2506 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2507 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2508 #define FLD(f) abuf->fields.fmt_empty.f
2509 int UNUSED written = 0;
2510 IADDR UNUSED pc = abuf->addr;
2511 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2512
2513 ((void) 0); /*nop*/
2514
2515 #undef FLD
2516 }
2517 NEXT (vpc);
2518
2519 CASE (sem, INSN_MFC0) : /* mfc0 $rt,$rd */
2520 {
2521 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2522 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2523 #define FLD(f) abuf->fields.fmt_empty.f
2524 int UNUSED written = 0;
2525 IADDR UNUSED pc = abuf->addr;
2526 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2527
2528 ((void) 0); /*nop*/
2529
2530 #undef FLD
2531 }
2532 NEXT (vpc);
2533
2534 CASE (sem, INSN_MFC1) : /* mfc1 $rt,$rd */
2535 {
2536 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2537 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2538 #define FLD(f) abuf->fields.fmt_empty.f
2539 int UNUSED written = 0;
2540 IADDR UNUSED pc = abuf->addr;
2541 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2542
2543 ((void) 0); /*nop*/
2544
2545 #undef FLD
2546 }
2547 NEXT (vpc);
2548
2549 CASE (sem, INSN_MFC2) : /* mfc2 $rt,$rd */
2550 {
2551 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2552 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2553 #define FLD(f) abuf->fields.fmt_empty.f
2554 int UNUSED written = 0;
2555 IADDR UNUSED pc = abuf->addr;
2556 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2557
2558 ((void) 0); /*nop*/
2559
2560 #undef FLD
2561 }
2562 NEXT (vpc);
2563
2564 CASE (sem, INSN_MFC3) : /* mfc3 $rt,$rd */
2565 {
2566 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2567 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2568 #define FLD(f) abuf->fields.fmt_empty.f
2569 int UNUSED written = 0;
2570 IADDR UNUSED pc = abuf->addr;
2571 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2572
2573 ((void) 0); /*nop*/
2574
2575 #undef FLD
2576 }
2577 NEXT (vpc);
2578
2579 CASE (sem, INSN_MTC0) : /* mtc0 $rt,$rd */
2580 {
2581 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2582 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2583 #define FLD(f) abuf->fields.fmt_empty.f
2584 int UNUSED written = 0;
2585 IADDR UNUSED pc = abuf->addr;
2586 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2587
2588 ((void) 0); /*nop*/
2589
2590 #undef FLD
2591 }
2592 NEXT (vpc);
2593
2594 CASE (sem, INSN_MTC1) : /* mtc1 $rt,$rd */
2595 {
2596 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2597 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2598 #define FLD(f) abuf->fields.fmt_empty.f
2599 int UNUSED written = 0;
2600 IADDR UNUSED pc = abuf->addr;
2601 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2602
2603 ((void) 0); /*nop*/
2604
2605 #undef FLD
2606 }
2607 NEXT (vpc);
2608
2609 CASE (sem, INSN_MTC2) : /* mtc2 $rt,$rd */
2610 {
2611 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2612 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2613 #define FLD(f) abuf->fields.fmt_empty.f
2614 int UNUSED written = 0;
2615 IADDR UNUSED pc = abuf->addr;
2616 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2617
2618 ((void) 0); /*nop*/
2619
2620 #undef FLD
2621 }
2622 NEXT (vpc);
2623
2624 CASE (sem, INSN_MTC3) : /* mtc3 $rt,$rd */
2625 {
2626 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2627 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2628 #define FLD(f) abuf->fields.fmt_empty.f
2629 int UNUSED written = 0;
2630 IADDR UNUSED pc = abuf->addr;
2631 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2632
2633 ((void) 0); /*nop*/
2634
2635 #undef FLD
2636 }
2637 NEXT (vpc);
2638
2639 CASE (sem, INSN_PKRL) : /* pkrl $rd,$rt */
2640 {
2641 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2642 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2643 #define FLD(f) abuf->fields.fmt_empty.f
2644 int UNUSED written = 0;
2645 IADDR UNUSED pc = abuf->addr;
2646 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2647
2648 ((void) 0); /*nop*/
2649
2650 #undef FLD
2651 }
2652 NEXT (vpc);
2653
2654 CASE (sem, INSN_PKRLR1) : /* pkrlr1 $rt,$index,$count */
2655 {
2656 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2657 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2658 #define FLD(f) abuf->fields.fmt_empty.f
2659 int UNUSED written = 0;
2660 IADDR UNUSED pc = abuf->addr;
2661 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2662
2663 ((void) 0); /*nop*/
2664
2665 #undef FLD
2666 }
2667 NEXT (vpc);
2668
2669 CASE (sem, INSN_PKRLR30) : /* pkrlr30 $rt,$index,$count */
2670 {
2671 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2672 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2673 #define FLD(f) abuf->fields.fmt_empty.f
2674 int UNUSED written = 0;
2675 IADDR UNUSED pc = abuf->addr;
2676 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2677
2678 ((void) 0); /*nop*/
2679
2680 #undef FLD
2681 }
2682 NEXT (vpc);
2683
2684 CASE (sem, INSN_RB) : /* rb $rd,$rt */
2685 {
2686 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2687 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2688 #define FLD(f) abuf->fields.fmt_empty.f
2689 int UNUSED written = 0;
2690 IADDR UNUSED pc = abuf->addr;
2691 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2692
2693 ((void) 0); /*nop*/
2694
2695 #undef FLD
2696 }
2697 NEXT (vpc);
2698
2699 CASE (sem, INSN_RBR1) : /* rbr1 $rt,$index,$count */
2700 {
2701 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2702 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2703 #define FLD(f) abuf->fields.fmt_empty.f
2704 int UNUSED written = 0;
2705 IADDR UNUSED pc = abuf->addr;
2706 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2707
2708 ((void) 0); /*nop*/
2709
2710 #undef FLD
2711 }
2712 NEXT (vpc);
2713
2714 CASE (sem, INSN_RBR30) : /* rbr30 $rt,$index,$count */
2715 {
2716 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2717 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2718 #define FLD(f) abuf->fields.fmt_empty.f
2719 int UNUSED written = 0;
2720 IADDR UNUSED pc = abuf->addr;
2721 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2722
2723 ((void) 0); /*nop*/
2724
2725 #undef FLD
2726 }
2727 NEXT (vpc);
2728
2729 CASE (sem, INSN_RFE) : /* rfe */
2730 {
2731 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2732 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2733 #define FLD(f) abuf->fields.fmt_empty.f
2734 int UNUSED written = 0;
2735 IADDR UNUSED pc = abuf->addr;
2736 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2737
2738 ((void) 0); /*nop*/
2739
2740 #undef FLD
2741 }
2742 NEXT (vpc);
2743
2744 CASE (sem, INSN_RX) : /* rx $rd,$rt */
2745 {
2746 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2747 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2748 #define FLD(f) abuf->fields.fmt_empty.f
2749 int UNUSED written = 0;
2750 IADDR UNUSED pc = abuf->addr;
2751 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2752
2753 ((void) 0); /*nop*/
2754
2755 #undef FLD
2756 }
2757 NEXT (vpc);
2758
2759 CASE (sem, INSN_RXR1) : /* rxr1 $rt,$index,$count */
2760 {
2761 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2762 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2763 #define FLD(f) abuf->fields.fmt_empty.f
2764 int UNUSED written = 0;
2765 IADDR UNUSED pc = abuf->addr;
2766 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2767
2768 ((void) 0); /*nop*/
2769
2770 #undef FLD
2771 }
2772 NEXT (vpc);
2773
2774 CASE (sem, INSN_RXR30) : /* rxr30 $rt,$index,$count */
2775 {
2776 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2777 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2778 #define FLD(f) abuf->fields.fmt_empty.f
2779 int UNUSED written = 0;
2780 IADDR UNUSED pc = abuf->addr;
2781 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2782
2783 ((void) 0); /*nop*/
2784
2785 #undef FLD
2786 }
2787 NEXT (vpc);
2788
2789 CASE (sem, INSN_SLEEP) : /* sleep */
2790 {
2791 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2792 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2793 #define FLD(f) abuf->fields.fmt_empty.f
2794 int UNUSED written = 0;
2795 IADDR UNUSED pc = abuf->addr;
2796 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2797
2798 ((void) 0); /*nop*/
2799
2800 #undef FLD
2801 }
2802 NEXT (vpc);
2803
2804 CASE (sem, INSN_SRRD) : /* srrd $rt */
2805 {
2806 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2807 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2808 #define FLD(f) abuf->fields.fmt_empty.f
2809 int UNUSED written = 0;
2810 IADDR UNUSED pc = abuf->addr;
2811 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2812
2813 ((void) 0); /*nop*/
2814
2815 #undef FLD
2816 }
2817 NEXT (vpc);
2818
2819 CASE (sem, INSN_SRRDL) : /* srrdl $rt */
2820 {
2821 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2822 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2823 #define FLD(f) abuf->fields.fmt_empty.f
2824 int UNUSED written = 0;
2825 IADDR UNUSED pc = abuf->addr;
2826 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2827
2828 ((void) 0); /*nop*/
2829
2830 #undef FLD
2831 }
2832 NEXT (vpc);
2833
2834 CASE (sem, INSN_SRULCK) : /* srulck $rt */
2835 {
2836 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2837 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2838 #define FLD(f) abuf->fields.fmt_empty.f
2839 int UNUSED written = 0;
2840 IADDR UNUSED pc = abuf->addr;
2841 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2842
2843 ((void) 0); /*nop*/
2844
2845 #undef FLD
2846 }
2847 NEXT (vpc);
2848
2849 CASE (sem, INSN_SRWR) : /* srwr $rt,$rd */
2850 {
2851 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2852 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2853 #define FLD(f) abuf->fields.fmt_empty.f
2854 int UNUSED written = 0;
2855 IADDR UNUSED pc = abuf->addr;
2856 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2857
2858 ((void) 0); /*nop*/
2859
2860 #undef FLD
2861 }
2862 NEXT (vpc);
2863
2864 CASE (sem, INSN_SRWRU) : /* srwru $rt,$rd */
2865 {
2866 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2867 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2868 #define FLD(f) abuf->fields.fmt_empty.f
2869 int UNUSED written = 0;
2870 IADDR UNUSED pc = abuf->addr;
2871 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2872
2873 ((void) 0); /*nop*/
2874
2875 #undef FLD
2876 }
2877 NEXT (vpc);
2878
2879 CASE (sem, INSN_TRAPQFL) : /* trapqfl */
2880 {
2881 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2882 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2883 #define FLD(f) abuf->fields.fmt_empty.f
2884 int UNUSED written = 0;
2885 IADDR UNUSED pc = abuf->addr;
2886 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2887
2888 ((void) 0); /*nop*/
2889
2890 #undef FLD
2891 }
2892 NEXT (vpc);
2893
2894 CASE (sem, INSN_TRAPQNE) : /* trapqne */
2895 {
2896 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2897 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2898 #define FLD(f) abuf->fields.fmt_empty.f
2899 int UNUSED written = 0;
2900 IADDR UNUSED pc = abuf->addr;
2901 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2902
2903 ((void) 0); /*nop*/
2904
2905 #undef FLD
2906 }
2907 NEXT (vpc);
2908
2909 CASE (sem, INSN_TRAPREL) : /* traprel $rt */
2910 {
2911 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2912 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2913 #define FLD(f) abuf->fields.fmt_empty.f
2914 int UNUSED written = 0;
2915 IADDR UNUSED pc = abuf->addr;
2916 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2917
2918 ((void) 0); /*nop*/
2919
2920 #undef FLD
2921 }
2922 NEXT (vpc);
2923
2924 CASE (sem, INSN_WB) : /* wb $rd,$rt */
2925 {
2926 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2927 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2928 #define FLD(f) abuf->fields.fmt_empty.f
2929 int UNUSED written = 0;
2930 IADDR UNUSED pc = abuf->addr;
2931 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2932
2933 ((void) 0); /*nop*/
2934
2935 #undef FLD
2936 }
2937 NEXT (vpc);
2938
2939 CASE (sem, INSN_WBU) : /* wbu $rd,$rt */
2940 {
2941 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2942 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2943 #define FLD(f) abuf->fields.fmt_empty.f
2944 int UNUSED written = 0;
2945 IADDR UNUSED pc = abuf->addr;
2946 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2947
2948 ((void) 0); /*nop*/
2949
2950 #undef FLD
2951 }
2952 NEXT (vpc);
2953
2954 CASE (sem, INSN_WBR1) : /* wbr1 $rt,$index,$count */
2955 {
2956 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2957 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2958 #define FLD(f) abuf->fields.fmt_empty.f
2959 int UNUSED written = 0;
2960 IADDR UNUSED pc = abuf->addr;
2961 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2962
2963 ((void) 0); /*nop*/
2964
2965 #undef FLD
2966 }
2967 NEXT (vpc);
2968
2969 CASE (sem, INSN_WBR1U) : /* wbr1u $rt,$index,$count */
2970 {
2971 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2972 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2973 #define FLD(f) abuf->fields.fmt_empty.f
2974 int UNUSED written = 0;
2975 IADDR UNUSED pc = abuf->addr;
2976 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2977
2978 ((void) 0); /*nop*/
2979
2980 #undef FLD
2981 }
2982 NEXT (vpc);
2983
2984 CASE (sem, INSN_WBR30) : /* wbr30 $rt,$index,$count */
2985 {
2986 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2987 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2988 #define FLD(f) abuf->fields.fmt_empty.f
2989 int UNUSED written = 0;
2990 IADDR UNUSED pc = abuf->addr;
2991 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2992
2993 ((void) 0); /*nop*/
2994
2995 #undef FLD
2996 }
2997 NEXT (vpc);
2998
2999 CASE (sem, INSN_WBR30U) : /* wbr30u $rt,$index,$count */
3000 {
3001 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3002 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3003 #define FLD(f) abuf->fields.fmt_empty.f
3004 int UNUSED written = 0;
3005 IADDR UNUSED pc = abuf->addr;
3006 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3007
3008 ((void) 0); /*nop*/
3009
3010 #undef FLD
3011 }
3012 NEXT (vpc);
3013
3014 CASE (sem, INSN_WX) : /* wx $rd,$rt */
3015 {
3016 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3017 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3018 #define FLD(f) abuf->fields.fmt_empty.f
3019 int UNUSED written = 0;
3020 IADDR UNUSED pc = abuf->addr;
3021 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3022
3023 ((void) 0); /*nop*/
3024
3025 #undef FLD
3026 }
3027 NEXT (vpc);
3028
3029 CASE (sem, INSN_WXU) : /* wxu $rd,$rt */
3030 {
3031 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3032 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3033 #define FLD(f) abuf->fields.fmt_empty.f
3034 int UNUSED written = 0;
3035 IADDR UNUSED pc = abuf->addr;
3036 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3037
3038 ((void) 0); /*nop*/
3039
3040 #undef FLD
3041 }
3042 NEXT (vpc);
3043
3044 CASE (sem, INSN_WXR1) : /* wxr1 $rt,$index,$count */
3045 {
3046 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3047 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3048 #define FLD(f) abuf->fields.fmt_empty.f
3049 int UNUSED written = 0;
3050 IADDR UNUSED pc = abuf->addr;
3051 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3052
3053 ((void) 0); /*nop*/
3054
3055 #undef FLD
3056 }
3057 NEXT (vpc);
3058
3059 CASE (sem, INSN_WXR1U) : /* wxr1u $rt,$index,$count */
3060 {
3061 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3062 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3063 #define FLD(f) abuf->fields.fmt_empty.f
3064 int UNUSED written = 0;
3065 IADDR UNUSED pc = abuf->addr;
3066 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3067
3068 ((void) 0); /*nop*/
3069
3070 #undef FLD
3071 }
3072 NEXT (vpc);
3073
3074 CASE (sem, INSN_WXR30) : /* wxr30 $rt,$index,$count */
3075 {
3076 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3077 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3078 #define FLD(f) abuf->fields.fmt_empty.f
3079 int UNUSED written = 0;
3080 IADDR UNUSED pc = abuf->addr;
3081 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3082
3083 ((void) 0); /*nop*/
3084
3085 #undef FLD
3086 }
3087 NEXT (vpc);
3088
3089 CASE (sem, INSN_WXR30U) : /* wxr30u $rt,$index,$count */
3090 {
3091 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3092 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3093 #define FLD(f) abuf->fields.fmt_empty.f
3094 int UNUSED written = 0;
3095 IADDR UNUSED pc = abuf->addr;
3096 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3097
3098 ((void) 0); /*nop*/
3099
3100 #undef FLD
3101 }
3102 NEXT (vpc);
3103
3104 CASE (sem, INSN_LDW) : /* ldw $rt,$lo16($base) */
3105 {
3106 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3107 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3108 #define FLD(f) abuf->fields.sfmt_addi.f
3109 int UNUSED written = 0;
3110 IADDR UNUSED pc = abuf->addr;
3111 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3112
3113 {
3114 SI tmp_addr;
3115 tmp_addr = ANDSI (ADDSI (GET_H_GR (FLD (f_rs)), FLD (f_imm)), INVSI (3));
3116 {
3117 SI opval = GETMEMSI (current_cpu, pc, tmp_addr);
3118 SET_H_GR (ADDSI (FLD (f_rt), 1), opval);
3119 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3120 }
3121 {
3122 SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_addr, 4));
3123 SET_H_GR (FLD (f_rt), opval);
3124 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3125 }
3126 }
3127
3128 #undef FLD
3129 }
3130 NEXT (vpc);
3131
3132 CASE (sem, INSN_SDW) : /* sdw $rt,$lo16($base) */
3133 {
3134 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3135 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3136 #define FLD(f) abuf->fields.sfmt_addi.f
3137 int UNUSED written = 0;
3138 IADDR UNUSED pc = abuf->addr;
3139 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3140
3141 {
3142 SI tmp_addr;
3143 tmp_addr = ANDSI (ADDSI (GET_H_GR (FLD (f_rs)), FLD (f_imm)), INVSI (3));
3144 {
3145 SI opval = GET_H_GR (FLD (f_rt));
3146 SETMEMSI (current_cpu, pc, ADDSI (tmp_addr, 4), opval);
3147 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
3148 }
3149 {
3150 SI opval = GET_H_GR (ADDSI (FLD (f_rt), 1));
3151 SETMEMSI (current_cpu, pc, tmp_addr, opval);
3152 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
3153 }
3154 }
3155
3156 #undef FLD
3157 }
3158 NEXT (vpc);
3159
3160 CASE (sem, INSN_J) : /* j $jmptarg */
3161 {
3162 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3163 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3164 #define FLD(f) abuf->fields.sfmt_j.f
3165 int UNUSED written = 0;
3166 IADDR UNUSED pc = abuf->addr;
3167 SEM_BRANCH_INIT
3168 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3169
3170 {
3171 {
3172 USI opval = FLD (i_jmptarg);
3173 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3174 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3175 }
3176 }
3177
3178 SEM_BRANCH_FINI (vpc);
3179 #undef FLD
3180 }
3181 NEXT (vpc);
3182
3183 CASE (sem, INSN_JAL) : /* jal $jmptarg */
3184 {
3185 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3186 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3187 #define FLD(f) abuf->fields.sfmt_j.f
3188 int UNUSED written = 0;
3189 IADDR UNUSED pc = abuf->addr;
3190 SEM_BRANCH_INIT
3191 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3192
3193 {
3194 {
3195 {
3196 SI opval = ADDSI (pc, 8);
3197 SET_H_GR (((UINT) 31), opval);
3198 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3199 }
3200 {
3201 USI opval = FLD (i_jmptarg);
3202 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3203 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3204 }
3205 }
3206 }
3207
3208 SEM_BRANCH_FINI (vpc);
3209 #undef FLD
3210 }
3211 NEXT (vpc);
3212
3213 CASE (sem, INSN_BMB) : /* bmb $rs,$rt,$offset */
3214 {
3215 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3216 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3217 #define FLD(f) abuf->fields.sfmt_bbi.f
3218 int UNUSED written = 0;
3219 IADDR UNUSED pc = abuf->addr;
3220 SEM_BRANCH_INIT
3221 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3222
3223 {
3224 BI tmp_branch_;
3225 tmp_branch_ = 0;
3226 if (EQSI (ANDSI (GET_H_GR (FLD (f_rs)), 255), ANDSI (GET_H_GR (FLD (f_rt)), 255))) {
3227 tmp_branch_ = 1;
3228 }
3229 if (EQSI (ANDSI (GET_H_GR (FLD (f_rs)), 65280), ANDSI (GET_H_GR (FLD (f_rt)), 65280))) {
3230 tmp_branch_ = 1;
3231 }
3232 if (EQSI (ANDSI (GET_H_GR (FLD (f_rs)), 16711680), ANDSI (GET_H_GR (FLD (f_rt)), 16711680))) {
3233 tmp_branch_ = 1;
3234 }
3235 if (EQSI (ANDSI (GET_H_GR (FLD (f_rs)), 0xff000000), ANDSI (GET_H_GR (FLD (f_rt)), 0xff000000))) {
3236 tmp_branch_ = 1;
3237 }
3238 if (tmp_branch_) {
3239 {
3240 {
3241 USI opval = FLD (i_offset);
3242 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3243 written |= (1 << 3);
3244 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3245 }
3246 }
3247 }
3248 }
3249
3250 abuf->written = written;
3251 SEM_BRANCH_FINI (vpc);
3252 #undef FLD
3253 }
3254 NEXT (vpc);
3255
3256
3257 }
3258 ENDSWITCH (sem) /* End of semantic switch. */
3259 ;
3260
3261 /* At this point `vpc' contains the next insn to execute. */
3262 }
3263
3264 #undef DEFINE_SWITCH
3265 #endif /* DEFINE_SWITCH */
The GNU Binutils are a collection of binary tools.