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