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
11the Free Software Foundation; either version 3 of the License, or
12(at your option) any later version.
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
19You should have received a copy of the GNU General Public License
20along with this program.  If not, see <http://www.gnu.org/licenses/>.
21
22*/
23
24#define WANT_CPU iq2000bf
25#define WANT_CPU_IQ2000BF
26
27#include "sim-main.h"
28#include "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
3544