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

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gdb/] [gdb-6.8/] [sim/] [iq2000/] [sem.c] - Blame information for rev 26

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 26 jlechner 
/* Simulator instruction semantics for iq2000bf.
2 
 
3 
THIS FILE IS MACHINE GENERATED WITH CGEN.
4 
 
5 
Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
6 
 
7 
This file is part of the GNU simulators.
8 
 
9 
This program is free software; you can redistribute it and/or modify
10 
it under the terms of the GNU General Public License as published by
11 
the Free Software Foundation; either version 3 of the License, or
12 
(at your option) any later version.
13 
 
14 
This program is distributed in the hope that it will be useful,
15 
but WITHOUT ANY WARRANTY; without even the implied warranty of
16 
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 
GNU General Public License for more details.
18 
 
19 
You should have received a copy of the GNU General Public License
20 
along with this program.  If not, see <http://www.gnu.org/licenses/>.
21 
 
22 
*/
23 
 
24 
#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 
 
51 
static SEM_PC
52 
SEM_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 
 
78 
static SEM_PC
79 
SEM_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 
 
99 
static SEM_PC
100 
SEM_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 
 
120 
static SEM_PC
121 
SEM_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 
 
150 
static SEM_PC
151 
SEM_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 
 
174 
static SEM_PC
175 
SEM_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 
 
205 
static SEM_PC
206 
SEM_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 
 
226 
static SEM_PC
227 
SEM_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 
 
247 
static SEM_PC
248 
SEM_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 
 
268 
static SEM_PC
269 
SEM_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 
 
289 
static SEM_PC
290 
SEM_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 
 
316 
static SEM_PC
317 
SEM_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 
 
337 
static SEM_PC
338 
SEM_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 
 
358 
static SEM_PC
359 
SEM_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 
 
379 
static SEM_PC
380 
SEM_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 
 
400 
static SEM_PC
401 
SEM_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 
 
421 
static SEM_PC
422 
SEM_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 
 
442 
static SEM_PC
443 
SEM_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 
 
475 
static SEM_PC
476 
SEM_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 
 
496 
static SEM_PC
497 
SEM_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 
 
517 
static SEM_PC
518 
SEM_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 
 
538 
static SEM_PC
539 
SEM_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 
 
547 
if (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 
 
570 
static SEM_PC
571 
SEM_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 
 
579 
if (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 
 
602 
static SEM_PC
603 
SEM_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 
 
611 
if (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 
 
634 
static SEM_PC
635 
SEM_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 
 
643 
if (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 
 
666 
static SEM_PC
667 
SEM_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 
 
687 
static SEM_PC
688 
SEM_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 
 
708 
static SEM_PC
709 
SEM_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 
 
729 
static SEM_PC
730 
SEM_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 
 
750 
static SEM_PC
751 
SEM_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 
 
771 
static SEM_PC
772 
SEM_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 
 
792 
static SEM_PC
793 
SEM_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 
 
813 
static SEM_PC
814 
SEM_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 
 
834 
static SEM_PC
835 
SEM_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 
 
855 
static SEM_PC
856 
SEM_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 
 
865 
if (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 
 
884 
static SEM_PC
885 
SEM_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 
 
894 
if (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 
 
913 
static SEM_PC
914 
SEM_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 
 
923 
if (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 
 
942 
static SEM_PC
943 
SEM_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 
 
952 
if (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 
 
971 
static SEM_PC
972 
SEM_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 
 
981 
if (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 
 
1000 
static SEM_PC
1001 
SEM_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 
 
1010 
if (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 {
1020 
if (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 
 
1032 
static SEM_PC
1033 
SEM_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 
 
1042 
if (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 
 
1061 
static SEM_PC
1062 
SEM_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 
 
1071 
if (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 
 
1098 
static SEM_PC
1099 
SEM_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 
 
1108 
if (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 {
1126 
if (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 
 
1138 
static SEM_PC
1139 
SEM_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 
 
1148 
if (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 {
1158 
if (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 
 
1170 
static SEM_PC
1171 
SEM_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 
 
1180 
if (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 
 
1199 
static SEM_PC
1200 
SEM_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 
 
1209 
if (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 {
1219 
if (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 
 
1231 
static SEM_PC
1232 
SEM_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 
 
1241 
if (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 
 
1268 
static SEM_PC
1269 
SEM_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 
 
1278 
if (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 {
1296 
if (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 
 
1308 
static SEM_PC
1309 
SEM_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 
 
1318 
if (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 
 
1337 
static SEM_PC
1338 
SEM_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 
 
1347 
if (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 
 
1366 
static SEM_PC
1367 
SEM_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 
 
1376 
if (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 
 
1395 
static SEM_PC
1396 
SEM_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 
 
1405 
if (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 
 
1424 
static SEM_PC
1425 
SEM_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 
 
1434 
if (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 
 
1453 
static SEM_PC
1454 
SEM_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 
 
1463 
if (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 {
1473 
if (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 
 
1485 
static SEM_PC
1486 
SEM_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 
 
1517 
static SEM_PC
1518 
SEM_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 
 
1542 
static SEM_PC
1543 
SEM_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 
 
1563 
static SEM_PC
1564 
SEM_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 
 
1584 
static SEM_PC
1585 
SEM_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 
 
1605 
static SEM_PC
1606 
SEM_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 
 
1626 
static SEM_PC
1627 
SEM_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 
 
1647 
static SEM_PC
1648 
SEM_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 
 
1668 
static SEM_PC
1669 
SEM_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 
 
1689 
static SEM_PC
1690 
SEM_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 
 
1710 
static SEM_PC
1711 
SEM_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 
 
1731 
static SEM_PC
1732 
SEM_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 
 
1740 
do_break (current_cpu, pc);
1741 
 
1742 
  return vpc;
1743 
#undef FLD
1744 
}
1745 
 
1746 
/* syscall: syscall */
1747 
 
1748 
static SEM_PC
1749 
SEM_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 
 
1757 
do_syscall (current_cpu);
1758 
 
1759 
  return vpc;
1760 
#undef FLD
1761 
}
1762 
 
1763 
/* andoui: andoui $rt,$rs,$hi16 */
1764 
 
1765 
static SEM_PC
1766 
SEM_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 
 
1786 
static SEM_PC
1787 
SEM_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 
 
1807 
static SEM_PC
1808 
SEM_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 
 
1817 
if (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 
 
1836 
static SEM_PC
1837 
SEM_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 
 
1846 
if (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 {
1856 
if (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 
 
1868 
static SEM_PC
1869 
SEM_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 
 
1878 
if (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 
 
1897 
static SEM_PC
1898 
SEM_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 
 
1907 
if (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 {
1917 
if (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 
 
1929 
static SEM_PC
1930 
SEM_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;
1940 
if (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 
}
1945 
if (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 
}
1950 
if (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 
}
1955 
if (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 
 
1973 
static SEM_PC
1974 
SEM_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 
 
1992 
static SEM_PC
1993 
SEM_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 
 
2011 
static SEM_PC
2012 
SEM_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 
 
2030 
static SEM_PC
2031 
SEM_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 
 
2049 
static SEM_PC
2050 
SEM_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 
 
2068 
static SEM_PC
2069 
SEM_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 
 
2087 
static SEM_PC
2088 
SEM_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 
 
2106 
static SEM_PC
2107 
SEM_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 
 
2125 
static SEM_PC
2126 
SEM_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 
 
2144 
static SEM_PC
2145 
SEM_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 
 
2161 
static SEM_PC
2162 
SEM_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 
 
2178 
static SEM_PC
2179 
SEM_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 
 
2195 
static SEM_PC
2196 
SEM_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 
 
2212 
static SEM_PC
2213 
SEM_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 
 
2229 
static SEM_PC
2230 
SEM_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 
 
2246 
static SEM_PC
2247 
SEM_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 
 
2263 
static SEM_PC
2264 
SEM_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 
 
2280 
static SEM_PC
2281 
SEM_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 
 
2297 
static SEM_PC
2298 
SEM_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 
 
2316 
static SEM_PC
2317 
SEM_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 
 
2333 
static SEM_PC
2334 
SEM_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 
 
2350 
static SEM_PC
2351 
SEM_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 
 
2367 
static SEM_PC
2368 
SEM_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 
 
2384 
static SEM_PC
2385 
SEM_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 
 
2401 
static SEM_PC
2402 
SEM_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 
 
2418 
static SEM_PC
2419 
SEM_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 
 
2435 
static SEM_PC
2436 
SEM_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 
 
2452 
static SEM_PC
2453 
SEM_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 
 
2469 
static SEM_PC
2470 
SEM_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 
 
2486 
static SEM_PC
2487 
SEM_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 
 
2503 
static SEM_PC
2504 
SEM_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 
 
2520 
static SEM_PC
2521 
SEM_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 
 
2537 
static SEM_PC
2538 
SEM_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 
 
2554 
static SEM_PC
2555 
SEM_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 
 
2571 
static SEM_PC
2572 
SEM_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 
 
2588 
static SEM_PC
2589 
SEM_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 
 
2605 
static SEM_PC
2606 
SEM_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 
 
2622 
static SEM_PC
2623 
SEM_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 
 
2639 
static SEM_PC
2640 
SEM_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 
 
2656 
static SEM_PC
2657 
SEM_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 
 
2673 
static SEM_PC
2674 
SEM_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 
 
2690 
static SEM_PC
2691 
SEM_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 
 
2707 
static SEM_PC
2708 
SEM_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 
 
2724 
static SEM_PC
2725 
SEM_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 
 
2741 
static SEM_PC
2742 
SEM_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 
 
2758 
static SEM_PC
2759 
SEM_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 
 
2775 
static SEM_PC
2776 
SEM_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 
 
2792 
static SEM_PC
2793 
SEM_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 
 
2809 
static SEM_PC
2810 
SEM_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 
 
2826 
static SEM_PC
2827 
SEM_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 
 
2843 
static SEM_PC
2844 
SEM_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 
 
2860 
static SEM_PC
2861 
SEM_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 
 
2877 
static SEM_PC
2878 
SEM_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 
 
2894 
static SEM_PC
2895 
SEM_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 
 
2911 
static SEM_PC
2912 
SEM_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 
 
2928 
static SEM_PC
2929 
SEM_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 
 
2945 
static SEM_PC
2946 
SEM_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 
 
2962 
static SEM_PC
2963 
SEM_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 
 
2979 
static SEM_PC
2980 
SEM_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 
 
2996 
static SEM_PC
2997 
SEM_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 
 
3013 
static SEM_PC
3014 
SEM_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 
 
3030 
static SEM_PC
3031 
SEM_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 
 
3047 
static SEM_PC
3048 
SEM_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 
 
3064 
static SEM_PC
3065 
SEM_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 
 
3081 
static SEM_PC
3082 
SEM_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 
 
3098 
static SEM_PC
3099 
SEM_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 
 
3115 
static SEM_PC
3116 
SEM_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 
 
3132 
static SEM_PC
3133 
SEM_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 
 
3149 
static SEM_PC
3150 
SEM_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 
 
3166 
static SEM_PC
3167 
SEM_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 
 
3183 
static SEM_PC
3184 
SEM_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 
 
3200 
static SEM_PC
3201 
SEM_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 
 
3230 
static SEM_PC
3231 
SEM_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 
 
3260 
static SEM_PC
3261 
SEM_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 
 
3285 
static SEM_PC
3286 
SEM_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 
 
3317 
static SEM_PC
3318 
SEM_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;
3330 
if (EQSI (ANDSI (GET_H_GR (FLD (f_rs)), 255), ANDSI (GET_H_GR (FLD (f_rt)), 255))) {
3331 
  tmp_branch_ = 1;
3332 
}
3333 
if (EQSI (ANDSI (GET_H_GR (FLD (f_rs)), 65280), ANDSI (GET_H_GR (FLD (f_rt)), 65280))) {
3334 
  tmp_branch_ = 1;
3335 
}
3336 
if (EQSI (ANDSI (GET_H_GR (FLD (f_rs)), 16711680), ANDSI (GET_H_GR (FLD (f_rt)), 16711680))) {
3337 
  tmp_branch_ = 1;
3338 
}
3339 
if (EQSI (ANDSI (GET_H_GR (FLD (f_rs)), 0xff000000), ANDSI (GET_H_GR (FLD (f_rt)), 0xff000000))) {
3340 
  tmp_branch_ = 1;
3341 
}
3342 
if (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 
 
3362 
static 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 
 
3518 
void
3519 
SEM_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 
 

powered by: WebSVN 2.1.0

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