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

Subversion Repositories or1k

[/] [or1k/] [tags/] [final_interface/] [gdb-5.0/] [sim/] [fr30/] [sem.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 106 markom 
/* Simulator instruction semantics for fr30bf.
2 
 
3 
THIS FILE IS MACHINE GENERATED WITH CGEN.
4 
 
5 
Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
6 
 
7 
This file is part of the GNU Simulators.
8 
 
9 
This program is free software; you can redistribute it and/or modify
10 
it under the terms of the GNU General Public License as published by
11 
the Free Software Foundation; either version 2, or (at your option)
12 
any later version.
13 
 
14 
This program is distributed in the hope that it will be useful,
15 
but WITHOUT ANY WARRANTY; without even the implied warranty of
16 
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 
GNU General Public License for more details.
18 
 
19 
You should have received a copy of the GNU General Public License along
20 
with this program; if not, write to the Free Software Foundation, Inc.,
21 
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 
 
23 
*/
24 
 
25 
#define WANT_CPU fr30bf
26 
#define WANT_CPU_FR30BF
27 
 
28 
#include "sim-main.h"
29 
#include "cgen-mem.h"
30 
#include "cgen-ops.h"
31 
 
32 
#undef GET_ATTR
33 
#define GET_ATTR(cpu, num, attr) CGEN_ATTR_VALUE (NULL, abuf->idesc->attrs, CGEN_INSN_##attr)
34 
 
35 
/* This is used so that we can compile two copies of the semantic code,
36 
   one with full feature support and one without that runs fast(er).
37 
   FAST_P, when desired, is defined on the command line, -DFAST_P=1.  */
38 
#if FAST_P
39 
#define SEM_FN_NAME(cpu,fn) XCONCAT3 (cpu,_semf_,fn)
40 
#undef TRACE_RESULT
41 
#define TRACE_RESULT(cpu, abuf, name, type, val)
42 
#else
43 
#define SEM_FN_NAME(cpu,fn) XCONCAT3 (cpu,_sem_,fn)
44 
#endif
45 
 
46 
/* x-invalid: --invalid-- */
47 
 
48 
static SEM_PC
49 
SEM_FN_NAME (fr30bf,x_invalid) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
50 
{
51 
#define FLD(f) abuf->fields.fmt_empty.f
52 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
53 
  int UNUSED written = 0;
54 
  IADDR UNUSED pc = abuf->addr;
55 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
56 
 
57 
  {
58 
    /* Update the recorded pc in the cpu state struct.
59 
       Only necessary for WITH_SCACHE case, but to avoid the
60 
       conditional compilation ....  */
61 
    SET_H_PC (pc);
62 
    /* Virtual insns have zero size.  Overwrite vpc with address of next insn
63 
       using the default-insn-bitsize spec.  When executing insns in parallel
64 
       we may want to queue the fault and continue execution.  */
65 
    vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
66 
    vpc = sim_engine_invalid_insn (current_cpu, pc, vpc);
67 
  }
68 
 
69 
  return vpc;
70 
#undef FLD
71 
}
72 
 
73 
/* x-after: --after-- */
74 
 
75 
static SEM_PC
76 
SEM_FN_NAME (fr30bf,x_after) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
77 
{
78 
#define FLD(f) abuf->fields.fmt_empty.f
79 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
80 
  int UNUSED written = 0;
81 
  IADDR UNUSED pc = abuf->addr;
82 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
83 
 
84 
  {
85 
#if WITH_SCACHE_PBB_FR30BF
86 
    fr30bf_pbb_after (current_cpu, sem_arg);
87 
#endif
88 
  }
89 
 
90 
  return vpc;
91 
#undef FLD
92 
}
93 
 
94 
/* x-before: --before-- */
95 
 
96 
static SEM_PC
97 
SEM_FN_NAME (fr30bf,x_before) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
98 
{
99 
#define FLD(f) abuf->fields.fmt_empty.f
100 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
101 
  int UNUSED written = 0;
102 
  IADDR UNUSED pc = abuf->addr;
103 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
104 
 
105 
  {
106 
#if WITH_SCACHE_PBB_FR30BF
107 
    fr30bf_pbb_before (current_cpu, sem_arg);
108 
#endif
109 
  }
110 
 
111 
  return vpc;
112 
#undef FLD
113 
}
114 
 
115 
/* x-cti-chain: --cti-chain-- */
116 
 
117 
static SEM_PC
118 
SEM_FN_NAME (fr30bf,x_cti_chain) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
119 
{
120 
#define FLD(f) abuf->fields.fmt_empty.f
121 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
122 
  int UNUSED written = 0;
123 
  IADDR UNUSED pc = abuf->addr;
124 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
125 
 
126 
  {
127 
#if WITH_SCACHE_PBB_FR30BF
128 
#ifdef DEFINE_SWITCH
129 
    vpc = fr30bf_pbb_cti_chain (current_cpu, sem_arg,
130 
                               pbb_br_type, pbb_br_npc);
131 
    BREAK (sem);
132 
#else
133 
    /* FIXME: Allow provision of explicit ifmt spec in insn spec.  */
134 
    vpc = fr30bf_pbb_cti_chain (current_cpu, sem_arg,
135 
                               CPU_PBB_BR_TYPE (current_cpu),
136 
                               CPU_PBB_BR_NPC (current_cpu));
137 
#endif
138 
#endif
139 
  }
140 
 
141 
  return vpc;
142 
#undef FLD
143 
}
144 
 
145 
/* x-chain: --chain-- */
146 
 
147 
static SEM_PC
148 
SEM_FN_NAME (fr30bf,x_chain) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
149 
{
150 
#define FLD(f) abuf->fields.fmt_empty.f
151 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
152 
  int UNUSED written = 0;
153 
  IADDR UNUSED pc = abuf->addr;
154 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
155 
 
156 
  {
157 
#if WITH_SCACHE_PBB_FR30BF
158 
    vpc = fr30bf_pbb_chain (current_cpu, sem_arg);
159 
#ifdef DEFINE_SWITCH
160 
    BREAK (sem);
161 
#endif
162 
#endif
163 
  }
164 
 
165 
  return vpc;
166 
#undef FLD
167 
}
168 
 
169 
/* x-begin: --begin-- */
170 
 
171 
static SEM_PC
172 
SEM_FN_NAME (fr30bf,x_begin) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
173 
{
174 
#define FLD(f) abuf->fields.fmt_empty.f
175 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
176 
  int UNUSED written = 0;
177 
  IADDR UNUSED pc = abuf->addr;
178 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
179 
 
180 
  {
181 
#if WITH_SCACHE_PBB_FR30BF
182 
#ifdef DEFINE_SWITCH
183 
    /* In the switch case FAST_P is a constant, allowing several optimizations
184 
       in any called inline functions.  */
185 
    vpc = fr30bf_pbb_begin (current_cpu, FAST_P);
186 
#else
187 
    vpc = fr30bf_pbb_begin (current_cpu, STATE_RUN_FAST_P (CPU_STATE (current_cpu)));
188 
#endif
189 
#endif
190 
  }
191 
 
192 
  return vpc;
193 
#undef FLD
194 
}
195 
 
196 
/* add: add $Rj,$Ri */
197 
 
198 
static SEM_PC
199 
SEM_FN_NAME (fr30bf,add) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
200 
{
201 
#define FLD(f) abuf->fields.sfmt_add.f
202 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
203 
  int UNUSED written = 0;
204 
  IADDR UNUSED pc = abuf->addr;
205 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
206 
 
207 
{
208 
  {
209 
    BI opval = ADDOFSI (* FLD (i_Ri), * FLD (i_Rj), 0);
210 
    CPU (h_vbit) = opval;
211 
    TRACE_RESULT (current_cpu, abuf, "vbit", 'x', opval);
212 
  }
213 
  {
214 
    BI opval = ADDCFSI (* FLD (i_Ri), * FLD (i_Rj), 0);
215 
    CPU (h_cbit) = opval;
216 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
217 
  }
218 
  {
219 
    SI opval = ADDSI (* FLD (i_Ri), * FLD (i_Rj));
220 
    * FLD (i_Ri) = opval;
221 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
222 
  }
223 
{
224 
  {
225 
    BI opval = EQSI (* FLD (i_Ri), 0);
226 
    CPU (h_zbit) = opval;
227 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
228 
  }
229 
  {
230 
    BI opval = LTSI (* FLD (i_Ri), 0);
231 
    CPU (h_nbit) = opval;
232 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
233 
  }
234 
}
235 
}
236 
 
237 
  return vpc;
238 
#undef FLD
239 
}
240 
 
241 
/* addi: add $u4,$Ri */
242 
 
243 
static SEM_PC
244 
SEM_FN_NAME (fr30bf,addi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
245 
{
246 
#define FLD(f) abuf->fields.sfmt_addi.f
247 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
248 
  int UNUSED written = 0;
249 
  IADDR UNUSED pc = abuf->addr;
250 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
251 
 
252 
{
253 
  {
254 
    BI opval = ADDOFSI (* FLD (i_Ri), FLD (f_u4), 0);
255 
    CPU (h_vbit) = opval;
256 
    TRACE_RESULT (current_cpu, abuf, "vbit", 'x', opval);
257 
  }
258 
  {
259 
    BI opval = ADDCFSI (* FLD (i_Ri), FLD (f_u4), 0);
260 
    CPU (h_cbit) = opval;
261 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
262 
  }
263 
  {
264 
    SI opval = ADDSI (* FLD (i_Ri), FLD (f_u4));
265 
    * FLD (i_Ri) = opval;
266 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
267 
  }
268 
{
269 
  {
270 
    BI opval = EQSI (* FLD (i_Ri), 0);
271 
    CPU (h_zbit) = opval;
272 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
273 
  }
274 
  {
275 
    BI opval = LTSI (* FLD (i_Ri), 0);
276 
    CPU (h_nbit) = opval;
277 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
278 
  }
279 
}
280 
}
281 
 
282 
  return vpc;
283 
#undef FLD
284 
}
285 
 
286 
/* add2: add2 $m4,$Ri */
287 
 
288 
static SEM_PC
289 
SEM_FN_NAME (fr30bf,add2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
290 
{
291 
#define FLD(f) abuf->fields.sfmt_add2.f
292 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
293 
  int UNUSED written = 0;
294 
  IADDR UNUSED pc = abuf->addr;
295 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
296 
 
297 
{
298 
  {
299 
    BI opval = ADDOFSI (* FLD (i_Ri), FLD (f_m4), 0);
300 
    CPU (h_vbit) = opval;
301 
    TRACE_RESULT (current_cpu, abuf, "vbit", 'x', opval);
302 
  }
303 
  {
304 
    BI opval = ADDCFSI (* FLD (i_Ri), FLD (f_m4), 0);
305 
    CPU (h_cbit) = opval;
306 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
307 
  }
308 
  {
309 
    SI opval = ADDSI (* FLD (i_Ri), FLD (f_m4));
310 
    * FLD (i_Ri) = opval;
311 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
312 
  }
313 
{
314 
  {
315 
    BI opval = EQSI (* FLD (i_Ri), 0);
316 
    CPU (h_zbit) = opval;
317 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
318 
  }
319 
  {
320 
    BI opval = LTSI (* FLD (i_Ri), 0);
321 
    CPU (h_nbit) = opval;
322 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
323 
  }
324 
}
325 
}
326 
 
327 
  return vpc;
328 
#undef FLD
329 
}
330 
 
331 
/* addc: addc $Rj,$Ri */
332 
 
333 
static SEM_PC
334 
SEM_FN_NAME (fr30bf,addc) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
335 
{
336 
#define FLD(f) abuf->fields.sfmt_add.f
337 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
338 
  int UNUSED written = 0;
339 
  IADDR UNUSED pc = abuf->addr;
340 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
341 
 
342 
{
343 
  SI tmp_tmp;
344 
  tmp_tmp = ADDCSI (* FLD (i_Ri), * FLD (i_Rj), CPU (h_cbit));
345 
  {
346 
    BI opval = ADDOFSI (* FLD (i_Ri), * FLD (i_Rj), CPU (h_cbit));
347 
    CPU (h_vbit) = opval;
348 
    TRACE_RESULT (current_cpu, abuf, "vbit", 'x', opval);
349 
  }
350 
  {
351 
    BI opval = ADDCFSI (* FLD (i_Ri), * FLD (i_Rj), CPU (h_cbit));
352 
    CPU (h_cbit) = opval;
353 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
354 
  }
355 
  {
356 
    SI opval = tmp_tmp;
357 
    * FLD (i_Ri) = opval;
358 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
359 
  }
360 
{
361 
  {
362 
    BI opval = EQSI (* FLD (i_Ri), 0);
363 
    CPU (h_zbit) = opval;
364 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
365 
  }
366 
  {
367 
    BI opval = LTSI (* FLD (i_Ri), 0);
368 
    CPU (h_nbit) = opval;
369 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
370 
  }
371 
}
372 
}
373 
 
374 
  return vpc;
375 
#undef FLD
376 
}
377 
 
378 
/* addn: addn $Rj,$Ri */
379 
 
380 
static SEM_PC
381 
SEM_FN_NAME (fr30bf,addn) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
382 
{
383 
#define FLD(f) abuf->fields.sfmt_add.f
384 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
385 
  int UNUSED written = 0;
386 
  IADDR UNUSED pc = abuf->addr;
387 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
388 
 
389 
  {
390 
    SI opval = ADDSI (* FLD (i_Ri), * FLD (i_Rj));
391 
    * FLD (i_Ri) = opval;
392 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
393 
  }
394 
 
395 
  return vpc;
396 
#undef FLD
397 
}
398 
 
399 
/* addni: addn $u4,$Ri */
400 
 
401 
static SEM_PC
402 
SEM_FN_NAME (fr30bf,addni) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
403 
{
404 
#define FLD(f) abuf->fields.sfmt_addi.f
405 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
406 
  int UNUSED written = 0;
407 
  IADDR UNUSED pc = abuf->addr;
408 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
409 
 
410 
  {
411 
    SI opval = ADDSI (* FLD (i_Ri), FLD (f_u4));
412 
    * FLD (i_Ri) = opval;
413 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
414 
  }
415 
 
416 
  return vpc;
417 
#undef FLD
418 
}
419 
 
420 
/* addn2: addn2 $m4,$Ri */
421 
 
422 
static SEM_PC
423 
SEM_FN_NAME (fr30bf,addn2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
424 
{
425 
#define FLD(f) abuf->fields.sfmt_add2.f
426 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
427 
  int UNUSED written = 0;
428 
  IADDR UNUSED pc = abuf->addr;
429 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
430 
 
431 
  {
432 
    SI opval = ADDSI (* FLD (i_Ri), FLD (f_m4));
433 
    * FLD (i_Ri) = opval;
434 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
435 
  }
436 
 
437 
  return vpc;
438 
#undef FLD
439 
}
440 
 
441 
/* sub: sub $Rj,$Ri */
442 
 
443 
static SEM_PC
444 
SEM_FN_NAME (fr30bf,sub) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
445 
{
446 
#define FLD(f) abuf->fields.sfmt_add.f
447 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
448 
  int UNUSED written = 0;
449 
  IADDR UNUSED pc = abuf->addr;
450 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
451 
 
452 
{
453 
  {
454 
    BI opval = SUBOFSI (* FLD (i_Ri), * FLD (i_Rj), 0);
455 
    CPU (h_vbit) = opval;
456 
    TRACE_RESULT (current_cpu, abuf, "vbit", 'x', opval);
457 
  }
458 
  {
459 
    BI opval = SUBCFSI (* FLD (i_Ri), * FLD (i_Rj), 0);
460 
    CPU (h_cbit) = opval;
461 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
462 
  }
463 
  {
464 
    SI opval = SUBSI (* FLD (i_Ri), * FLD (i_Rj));
465 
    * FLD (i_Ri) = opval;
466 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
467 
  }
468 
{
469 
  {
470 
    BI opval = EQSI (* FLD (i_Ri), 0);
471 
    CPU (h_zbit) = opval;
472 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
473 
  }
474 
  {
475 
    BI opval = LTSI (* FLD (i_Ri), 0);
476 
    CPU (h_nbit) = opval;
477 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
478 
  }
479 
}
480 
}
481 
 
482 
  return vpc;
483 
#undef FLD
484 
}
485 
 
486 
/* subc: subc $Rj,$Ri */
487 
 
488 
static SEM_PC
489 
SEM_FN_NAME (fr30bf,subc) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
490 
{
491 
#define FLD(f) abuf->fields.sfmt_add.f
492 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
493 
  int UNUSED written = 0;
494 
  IADDR UNUSED pc = abuf->addr;
495 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
496 
 
497 
{
498 
  SI tmp_tmp;
499 
  tmp_tmp = SUBCSI (* FLD (i_Ri), * FLD (i_Rj), CPU (h_cbit));
500 
  {
501 
    BI opval = SUBOFSI (* FLD (i_Ri), * FLD (i_Rj), CPU (h_cbit));
502 
    CPU (h_vbit) = opval;
503 
    TRACE_RESULT (current_cpu, abuf, "vbit", 'x', opval);
504 
  }
505 
  {
506 
    BI opval = SUBCFSI (* FLD (i_Ri), * FLD (i_Rj), CPU (h_cbit));
507 
    CPU (h_cbit) = opval;
508 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
509 
  }
510 
  {
511 
    SI opval = tmp_tmp;
512 
    * FLD (i_Ri) = opval;
513 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
514 
  }
515 
{
516 
  {
517 
    BI opval = EQSI (* FLD (i_Ri), 0);
518 
    CPU (h_zbit) = opval;
519 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
520 
  }
521 
  {
522 
    BI opval = LTSI (* FLD (i_Ri), 0);
523 
    CPU (h_nbit) = opval;
524 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
525 
  }
526 
}
527 
}
528 
 
529 
  return vpc;
530 
#undef FLD
531 
}
532 
 
533 
/* subn: subn $Rj,$Ri */
534 
 
535 
static SEM_PC
536 
SEM_FN_NAME (fr30bf,subn) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
537 
{
538 
#define FLD(f) abuf->fields.sfmt_add.f
539 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
540 
  int UNUSED written = 0;
541 
  IADDR UNUSED pc = abuf->addr;
542 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
543 
 
544 
  {
545 
    SI opval = SUBSI (* FLD (i_Ri), * FLD (i_Rj));
546 
    * FLD (i_Ri) = opval;
547 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
548 
  }
549 
 
550 
  return vpc;
551 
#undef FLD
552 
}
553 
 
554 
/* cmp: cmp $Rj,$Ri */
555 
 
556 
static SEM_PC
557 
SEM_FN_NAME (fr30bf,cmp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
558 
{
559 
#define FLD(f) abuf->fields.sfmt_str13.f
560 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
561 
  int UNUSED written = 0;
562 
  IADDR UNUSED pc = abuf->addr;
563 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
564 
 
565 
{
566 
  SI tmp_tmp1;
567 
  {
568 
    BI opval = SUBOFSI (* FLD (i_Ri), * FLD (i_Rj), 0);
569 
    CPU (h_vbit) = opval;
570 
    TRACE_RESULT (current_cpu, abuf, "vbit", 'x', opval);
571 
  }
572 
  {
573 
    BI opval = SUBCFSI (* FLD (i_Ri), * FLD (i_Rj), 0);
574 
    CPU (h_cbit) = opval;
575 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
576 
  }
577 
  tmp_tmp1 = SUBSI (* FLD (i_Ri), * FLD (i_Rj));
578 
{
579 
  {
580 
    BI opval = EQSI (tmp_tmp1, 0);
581 
    CPU (h_zbit) = opval;
582 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
583 
  }
584 
  {
585 
    BI opval = LTSI (tmp_tmp1, 0);
586 
    CPU (h_nbit) = opval;
587 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
588 
  }
589 
}
590 
}
591 
 
592 
  return vpc;
593 
#undef FLD
594 
}
595 
 
596 
/* cmpi: cmp $u4,$Ri */
597 
 
598 
static SEM_PC
599 
SEM_FN_NAME (fr30bf,cmpi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
600 
{
601 
#define FLD(f) abuf->fields.sfmt_addi.f
602 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
603 
  int UNUSED written = 0;
604 
  IADDR UNUSED pc = abuf->addr;
605 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
606 
 
607 
{
608 
  SI tmp_tmp1;
609 
  {
610 
    BI opval = SUBOFSI (* FLD (i_Ri), FLD (f_u4), 0);
611 
    CPU (h_vbit) = opval;
612 
    TRACE_RESULT (current_cpu, abuf, "vbit", 'x', opval);
613 
  }
614 
  {
615 
    BI opval = SUBCFSI (* FLD (i_Ri), FLD (f_u4), 0);
616 
    CPU (h_cbit) = opval;
617 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
618 
  }
619 
  tmp_tmp1 = SUBSI (* FLD (i_Ri), FLD (f_u4));
620 
{
621 
  {
622 
    BI opval = EQSI (tmp_tmp1, 0);
623 
    CPU (h_zbit) = opval;
624 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
625 
  }
626 
  {
627 
    BI opval = LTSI (tmp_tmp1, 0);
628 
    CPU (h_nbit) = opval;
629 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
630 
  }
631 
}
632 
}
633 
 
634 
  return vpc;
635 
#undef FLD
636 
}
637 
 
638 
/* cmp2: cmp2 $m4,$Ri */
639 
 
640 
static SEM_PC
641 
SEM_FN_NAME (fr30bf,cmp2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
642 
{
643 
#define FLD(f) abuf->fields.sfmt_add2.f
644 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
645 
  int UNUSED written = 0;
646 
  IADDR UNUSED pc = abuf->addr;
647 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
648 
 
649 
{
650 
  SI tmp_tmp1;
651 
  {
652 
    BI opval = SUBOFSI (* FLD (i_Ri), FLD (f_m4), 0);
653 
    CPU (h_vbit) = opval;
654 
    TRACE_RESULT (current_cpu, abuf, "vbit", 'x', opval);
655 
  }
656 
  {
657 
    BI opval = SUBCFSI (* FLD (i_Ri), FLD (f_m4), 0);
658 
    CPU (h_cbit) = opval;
659 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
660 
  }
661 
  tmp_tmp1 = SUBSI (* FLD (i_Ri), FLD (f_m4));
662 
{
663 
  {
664 
    BI opval = EQSI (tmp_tmp1, 0);
665 
    CPU (h_zbit) = opval;
666 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
667 
  }
668 
  {
669 
    BI opval = LTSI (tmp_tmp1, 0);
670 
    CPU (h_nbit) = opval;
671 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
672 
  }
673 
}
674 
}
675 
 
676 
  return vpc;
677 
#undef FLD
678 
}
679 
 
680 
/* and: and $Rj,$Ri */
681 
 
682 
static SEM_PC
683 
SEM_FN_NAME (fr30bf,and) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
684 
{
685 
#define FLD(f) abuf->fields.sfmt_add.f
686 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
687 
  int UNUSED written = 0;
688 
  IADDR UNUSED pc = abuf->addr;
689 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
690 
 
691 
{
692 
  {
693 
    SI opval = ANDSI (* FLD (i_Ri), * FLD (i_Rj));
694 
    * FLD (i_Ri) = opval;
695 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
696 
  }
697 
{
698 
  {
699 
    BI opval = EQSI (* FLD (i_Ri), 0);
700 
    CPU (h_zbit) = opval;
701 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
702 
  }
703 
  {
704 
    BI opval = LTSI (* FLD (i_Ri), 0);
705 
    CPU (h_nbit) = opval;
706 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
707 
  }
708 
}
709 
}
710 
 
711 
  return vpc;
712 
#undef FLD
713 
}
714 
 
715 
/* or: or $Rj,$Ri */
716 
 
717 
static SEM_PC
718 
SEM_FN_NAME (fr30bf,or) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
719 
{
720 
#define FLD(f) abuf->fields.sfmt_add.f
721 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
722 
  int UNUSED written = 0;
723 
  IADDR UNUSED pc = abuf->addr;
724 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
725 
 
726 
{
727 
  {
728 
    SI opval = ORSI (* FLD (i_Ri), * FLD (i_Rj));
729 
    * FLD (i_Ri) = opval;
730 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
731 
  }
732 
{
733 
  {
734 
    BI opval = EQSI (* FLD (i_Ri), 0);
735 
    CPU (h_zbit) = opval;
736 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
737 
  }
738 
  {
739 
    BI opval = LTSI (* FLD (i_Ri), 0);
740 
    CPU (h_nbit) = opval;
741 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
742 
  }
743 
}
744 
}
745 
 
746 
  return vpc;
747 
#undef FLD
748 
}
749 
 
750 
/* eor: eor $Rj,$Ri */
751 
 
752 
static SEM_PC
753 
SEM_FN_NAME (fr30bf,eor) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
754 
{
755 
#define FLD(f) abuf->fields.sfmt_add.f
756 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
757 
  int UNUSED written = 0;
758 
  IADDR UNUSED pc = abuf->addr;
759 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
760 
 
761 
{
762 
  {
763 
    SI opval = XORSI (* FLD (i_Ri), * FLD (i_Rj));
764 
    * FLD (i_Ri) = opval;
765 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
766 
  }
767 
{
768 
  {
769 
    BI opval = EQSI (* FLD (i_Ri), 0);
770 
    CPU (h_zbit) = opval;
771 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
772 
  }
773 
  {
774 
    BI opval = LTSI (* FLD (i_Ri), 0);
775 
    CPU (h_nbit) = opval;
776 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
777 
  }
778 
}
779 
}
780 
 
781 
  return vpc;
782 
#undef FLD
783 
}
784 
 
785 
/* andm: and $Rj,@$Ri */
786 
 
787 
static SEM_PC
788 
SEM_FN_NAME (fr30bf,andm) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
789 
{
790 
#define FLD(f) abuf->fields.sfmt_str13.f
791 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
792 
  int UNUSED written = 0;
793 
  IADDR UNUSED pc = abuf->addr;
794 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
795 
 
796 
{
797 
  SI tmp_tmp;
798 
  tmp_tmp = ANDSI (GETMEMSI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
799 
{
800 
  {
801 
    BI opval = EQSI (tmp_tmp, 0);
802 
    CPU (h_zbit) = opval;
803 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
804 
  }
805 
  {
806 
    BI opval = LTSI (tmp_tmp, 0);
807 
    CPU (h_nbit) = opval;
808 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
809 
  }
810 
}
811 
  {
812 
    SI opval = tmp_tmp;
813 
    SETMEMSI (current_cpu, pc, * FLD (i_Ri), opval);
814 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
815 
  }
816 
}
817 
 
818 
  return vpc;
819 
#undef FLD
820 
}
821 
 
822 
/* andh: andh $Rj,@$Ri */
823 
 
824 
static SEM_PC
825 
SEM_FN_NAME (fr30bf,andh) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
826 
{
827 
#define FLD(f) abuf->fields.sfmt_str13.f
828 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
829 
  int UNUSED written = 0;
830 
  IADDR UNUSED pc = abuf->addr;
831 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
832 
 
833 
{
834 
  HI tmp_tmp;
835 
  tmp_tmp = ANDHI (GETMEMHI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
836 
{
837 
  {
838 
    BI opval = EQHI (tmp_tmp, 0);
839 
    CPU (h_zbit) = opval;
840 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
841 
  }
842 
  {
843 
    BI opval = LTHI (tmp_tmp, 0);
844 
    CPU (h_nbit) = opval;
845 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
846 
  }
847 
}
848 
  {
849 
    HI opval = tmp_tmp;
850 
    SETMEMHI (current_cpu, pc, * FLD (i_Ri), opval);
851 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
852 
  }
853 
}
854 
 
855 
  return vpc;
856 
#undef FLD
857 
}
858 
 
859 
/* andb: andb $Rj,@$Ri */
860 
 
861 
static SEM_PC
862 
SEM_FN_NAME (fr30bf,andb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
863 
{
864 
#define FLD(f) abuf->fields.sfmt_str13.f
865 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
866 
  int UNUSED written = 0;
867 
  IADDR UNUSED pc = abuf->addr;
868 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
869 
 
870 
{
871 
  QI tmp_tmp;
872 
  tmp_tmp = ANDQI (GETMEMQI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
873 
{
874 
  {
875 
    BI opval = EQQI (tmp_tmp, 0);
876 
    CPU (h_zbit) = opval;
877 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
878 
  }
879 
  {
880 
    BI opval = LTQI (tmp_tmp, 0);
881 
    CPU (h_nbit) = opval;
882 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
883 
  }
884 
}
885 
  {
886 
    QI opval = tmp_tmp;
887 
    SETMEMQI (current_cpu, pc, * FLD (i_Ri), opval);
888 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
889 
  }
890 
}
891 
 
892 
  return vpc;
893 
#undef FLD
894 
}
895 
 
896 
/* orm: or $Rj,@$Ri */
897 
 
898 
static SEM_PC
899 
SEM_FN_NAME (fr30bf,orm) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
900 
{
901 
#define FLD(f) abuf->fields.sfmt_str13.f
902 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
903 
  int UNUSED written = 0;
904 
  IADDR UNUSED pc = abuf->addr;
905 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
906 
 
907 
{
908 
  SI tmp_tmp;
909 
  tmp_tmp = ORSI (GETMEMSI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
910 
{
911 
  {
912 
    BI opval = EQSI (tmp_tmp, 0);
913 
    CPU (h_zbit) = opval;
914 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
915 
  }
916 
  {
917 
    BI opval = LTSI (tmp_tmp, 0);
918 
    CPU (h_nbit) = opval;
919 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
920 
  }
921 
}
922 
  {
923 
    SI opval = tmp_tmp;
924 
    SETMEMSI (current_cpu, pc, * FLD (i_Ri), opval);
925 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
926 
  }
927 
}
928 
 
929 
  return vpc;
930 
#undef FLD
931 
}
932 
 
933 
/* orh: orh $Rj,@$Ri */
934 
 
935 
static SEM_PC
936 
SEM_FN_NAME (fr30bf,orh) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
937 
{
938 
#define FLD(f) abuf->fields.sfmt_str13.f
939 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
940 
  int UNUSED written = 0;
941 
  IADDR UNUSED pc = abuf->addr;
942 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
943 
 
944 
{
945 
  HI tmp_tmp;
946 
  tmp_tmp = ORHI (GETMEMHI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
947 
{
948 
  {
949 
    BI opval = EQHI (tmp_tmp, 0);
950 
    CPU (h_zbit) = opval;
951 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
952 
  }
953 
  {
954 
    BI opval = LTHI (tmp_tmp, 0);
955 
    CPU (h_nbit) = opval;
956 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
957 
  }
958 
}
959 
  {
960 
    HI opval = tmp_tmp;
961 
    SETMEMHI (current_cpu, pc, * FLD (i_Ri), opval);
962 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
963 
  }
964 
}
965 
 
966 
  return vpc;
967 
#undef FLD
968 
}
969 
 
970 
/* orb: orb $Rj,@$Ri */
971 
 
972 
static SEM_PC
973 
SEM_FN_NAME (fr30bf,orb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
974 
{
975 
#define FLD(f) abuf->fields.sfmt_str13.f
976 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
977 
  int UNUSED written = 0;
978 
  IADDR UNUSED pc = abuf->addr;
979 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
980 
 
981 
{
982 
  QI tmp_tmp;
983 
  tmp_tmp = ORQI (GETMEMQI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
984 
{
985 
  {
986 
    BI opval = EQQI (tmp_tmp, 0);
987 
    CPU (h_zbit) = opval;
988 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
989 
  }
990 
  {
991 
    BI opval = LTQI (tmp_tmp, 0);
992 
    CPU (h_nbit) = opval;
993 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
994 
  }
995 
}
996 
  {
997 
    QI opval = tmp_tmp;
998 
    SETMEMQI (current_cpu, pc, * FLD (i_Ri), opval);
999 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
1000 
  }
1001 
}
1002 
 
1003 
  return vpc;
1004 
#undef FLD
1005 
}
1006 
 
1007 
/* eorm: eor $Rj,@$Ri */
1008 
 
1009 
static SEM_PC
1010 
SEM_FN_NAME (fr30bf,eorm) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1011 
{
1012 
#define FLD(f) abuf->fields.sfmt_str13.f
1013 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1014 
  int UNUSED written = 0;
1015 
  IADDR UNUSED pc = abuf->addr;
1016 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1017 
 
1018 
{
1019 
  SI tmp_tmp;
1020 
  tmp_tmp = XORSI (GETMEMSI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
1021 
{
1022 
  {
1023 
    BI opval = EQSI (tmp_tmp, 0);
1024 
    CPU (h_zbit) = opval;
1025 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
1026 
  }
1027 
  {
1028 
    BI opval = LTSI (tmp_tmp, 0);
1029 
    CPU (h_nbit) = opval;
1030 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
1031 
  }
1032 
}
1033 
  {
1034 
    SI opval = tmp_tmp;
1035 
    SETMEMSI (current_cpu, pc, * FLD (i_Ri), opval);
1036 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
1037 
  }
1038 
}
1039 
 
1040 
  return vpc;
1041 
#undef FLD
1042 
}
1043 
 
1044 
/* eorh: eorh $Rj,@$Ri */
1045 
 
1046 
static SEM_PC
1047 
SEM_FN_NAME (fr30bf,eorh) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1048 
{
1049 
#define FLD(f) abuf->fields.sfmt_str13.f
1050 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1051 
  int UNUSED written = 0;
1052 
  IADDR UNUSED pc = abuf->addr;
1053 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1054 
 
1055 
{
1056 
  HI tmp_tmp;
1057 
  tmp_tmp = XORHI (GETMEMHI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
1058 
{
1059 
  {
1060 
    BI opval = EQHI (tmp_tmp, 0);
1061 
    CPU (h_zbit) = opval;
1062 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
1063 
  }
1064 
  {
1065 
    BI opval = LTHI (tmp_tmp, 0);
1066 
    CPU (h_nbit) = opval;
1067 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
1068 
  }
1069 
}
1070 
  {
1071 
    HI opval = tmp_tmp;
1072 
    SETMEMHI (current_cpu, pc, * FLD (i_Ri), opval);
1073 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
1074 
  }
1075 
}
1076 
 
1077 
  return vpc;
1078 
#undef FLD
1079 
}
1080 
 
1081 
/* eorb: eorb $Rj,@$Ri */
1082 
 
1083 
static SEM_PC
1084 
SEM_FN_NAME (fr30bf,eorb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1085 
{
1086 
#define FLD(f) abuf->fields.sfmt_str13.f
1087 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1088 
  int UNUSED written = 0;
1089 
  IADDR UNUSED pc = abuf->addr;
1090 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1091 
 
1092 
{
1093 
  QI tmp_tmp;
1094 
  tmp_tmp = XORQI (GETMEMQI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
1095 
{
1096 
  {
1097 
    BI opval = EQQI (tmp_tmp, 0);
1098 
    CPU (h_zbit) = opval;
1099 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
1100 
  }
1101 
  {
1102 
    BI opval = LTQI (tmp_tmp, 0);
1103 
    CPU (h_nbit) = opval;
1104 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
1105 
  }
1106 
}
1107 
  {
1108 
    QI opval = tmp_tmp;
1109 
    SETMEMQI (current_cpu, pc, * FLD (i_Ri), opval);
1110 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
1111 
  }
1112 
}
1113 
 
1114 
  return vpc;
1115 
#undef FLD
1116 
}
1117 
 
1118 
/* bandl: bandl $u4,@$Ri */
1119 
 
1120 
static SEM_PC
1121 
SEM_FN_NAME (fr30bf,bandl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1122 
{
1123 
#define FLD(f) abuf->fields.sfmt_addi.f
1124 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1125 
  int UNUSED written = 0;
1126 
  IADDR UNUSED pc = abuf->addr;
1127 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1128 
 
1129 
  {
1130 
    QI opval = ANDQI (ORQI (FLD (f_u4), 240), GETMEMQI (current_cpu, pc, * FLD (i_Ri)));
1131 
    SETMEMQI (current_cpu, pc, * FLD (i_Ri), opval);
1132 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
1133 
  }
1134 
 
1135 
  return vpc;
1136 
#undef FLD
1137 
}
1138 
 
1139 
/* borl: borl $u4,@$Ri */
1140 
 
1141 
static SEM_PC
1142 
SEM_FN_NAME (fr30bf,borl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1143 
{
1144 
#define FLD(f) abuf->fields.sfmt_addi.f
1145 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1146 
  int UNUSED written = 0;
1147 
  IADDR UNUSED pc = abuf->addr;
1148 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1149 
 
1150 
  {
1151 
    QI opval = ORQI (FLD (f_u4), GETMEMQI (current_cpu, pc, * FLD (i_Ri)));
1152 
    SETMEMQI (current_cpu, pc, * FLD (i_Ri), opval);
1153 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
1154 
  }
1155 
 
1156 
  return vpc;
1157 
#undef FLD
1158 
}
1159 
 
1160 
/* beorl: beorl $u4,@$Ri */
1161 
 
1162 
static SEM_PC
1163 
SEM_FN_NAME (fr30bf,beorl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1164 
{
1165 
#define FLD(f) abuf->fields.sfmt_addi.f
1166 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1167 
  int UNUSED written = 0;
1168 
  IADDR UNUSED pc = abuf->addr;
1169 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1170 
 
1171 
  {
1172 
    QI opval = XORQI (FLD (f_u4), GETMEMQI (current_cpu, pc, * FLD (i_Ri)));
1173 
    SETMEMQI (current_cpu, pc, * FLD (i_Ri), opval);
1174 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
1175 
  }
1176 
 
1177 
  return vpc;
1178 
#undef FLD
1179 
}
1180 
 
1181 
/* bandh: bandh $u4,@$Ri */
1182 
 
1183 
static SEM_PC
1184 
SEM_FN_NAME (fr30bf,bandh) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1185 
{
1186 
#define FLD(f) abuf->fields.sfmt_addi.f
1187 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1188 
  int UNUSED written = 0;
1189 
  IADDR UNUSED pc = abuf->addr;
1190 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1191 
 
1192 
  {
1193 
    QI opval = ANDQI (ORQI (SLLQI (FLD (f_u4), 4), 15), GETMEMQI (current_cpu, pc, * FLD (i_Ri)));
1194 
    SETMEMQI (current_cpu, pc, * FLD (i_Ri), opval);
1195 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
1196 
  }
1197 
 
1198 
  return vpc;
1199 
#undef FLD
1200 
}
1201 
 
1202 
/* borh: borh $u4,@$Ri */
1203 
 
1204 
static SEM_PC
1205 
SEM_FN_NAME (fr30bf,borh) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1206 
{
1207 
#define FLD(f) abuf->fields.sfmt_addi.f
1208 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1209 
  int UNUSED written = 0;
1210 
  IADDR UNUSED pc = abuf->addr;
1211 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1212 
 
1213 
  {
1214 
    QI opval = ORQI (SLLQI (FLD (f_u4), 4), GETMEMQI (current_cpu, pc, * FLD (i_Ri)));
1215 
    SETMEMQI (current_cpu, pc, * FLD (i_Ri), opval);
1216 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
1217 
  }
1218 
 
1219 
  return vpc;
1220 
#undef FLD
1221 
}
1222 
 
1223 
/* beorh: beorh $u4,@$Ri */
1224 
 
1225 
static SEM_PC
1226 
SEM_FN_NAME (fr30bf,beorh) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1227 
{
1228 
#define FLD(f) abuf->fields.sfmt_addi.f
1229 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1230 
  int UNUSED written = 0;
1231 
  IADDR UNUSED pc = abuf->addr;
1232 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1233 
 
1234 
  {
1235 
    QI opval = XORQI (SLLQI (FLD (f_u4), 4), GETMEMQI (current_cpu, pc, * FLD (i_Ri)));
1236 
    SETMEMQI (current_cpu, pc, * FLD (i_Ri), opval);
1237 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
1238 
  }
1239 
 
1240 
  return vpc;
1241 
#undef FLD
1242 
}
1243 
 
1244 
/* btstl: btstl $u4,@$Ri */
1245 
 
1246 
static SEM_PC
1247 
SEM_FN_NAME (fr30bf,btstl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1248 
{
1249 
#define FLD(f) abuf->fields.sfmt_addi.f
1250 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1251 
  int UNUSED written = 0;
1252 
  IADDR UNUSED pc = abuf->addr;
1253 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1254 
 
1255 
{
1256 
  QI tmp_tmp;
1257 
  tmp_tmp = ANDQI (FLD (f_u4), GETMEMQI (current_cpu, pc, * FLD (i_Ri)));
1258 
  {
1259 
    BI opval = EQQI (tmp_tmp, 0);
1260 
    CPU (h_zbit) = opval;
1261 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
1262 
  }
1263 
  {
1264 
    BI opval = 0;
1265 
    CPU (h_nbit) = opval;
1266 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
1267 
  }
1268 
}
1269 
 
1270 
  return vpc;
1271 
#undef FLD
1272 
}
1273 
 
1274 
/* btsth: btsth $u4,@$Ri */
1275 
 
1276 
static SEM_PC
1277 
SEM_FN_NAME (fr30bf,btsth) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1278 
{
1279 
#define FLD(f) abuf->fields.sfmt_addi.f
1280 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1281 
  int UNUSED written = 0;
1282 
  IADDR UNUSED pc = abuf->addr;
1283 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1284 
 
1285 
{
1286 
  QI tmp_tmp;
1287 
  tmp_tmp = ANDQI (SLLQI (FLD (f_u4), 4), GETMEMQI (current_cpu, pc, * FLD (i_Ri)));
1288 
  {
1289 
    BI opval = EQQI (tmp_tmp, 0);
1290 
    CPU (h_zbit) = opval;
1291 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
1292 
  }
1293 
  {
1294 
    BI opval = LTQI (tmp_tmp, 0);
1295 
    CPU (h_nbit) = opval;
1296 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
1297 
  }
1298 
}
1299 
 
1300 
  return vpc;
1301 
#undef FLD
1302 
}
1303 
 
1304 
/* mul: mul $Rj,$Ri */
1305 
 
1306 
static SEM_PC
1307 
SEM_FN_NAME (fr30bf,mul) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1308 
{
1309 
#define FLD(f) abuf->fields.sfmt_str13.f
1310 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1311 
  int UNUSED written = 0;
1312 
  IADDR UNUSED pc = abuf->addr;
1313 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1314 
 
1315 
{
1316 
  DI tmp_tmp;
1317 
  tmp_tmp = MULDI (EXTSIDI (* FLD (i_Rj)), EXTSIDI (* FLD (i_Ri)));
1318 
  {
1319 
    SI opval = TRUNCDISI (tmp_tmp);
1320 
    SET_H_DR (((UINT) 5), opval);
1321 
    TRACE_RESULT (current_cpu, abuf, "dr-5", 'x', opval);
1322 
  }
1323 
  {
1324 
    SI opval = TRUNCDISI (SRLDI (tmp_tmp, 32));
1325 
    SET_H_DR (((UINT) 4), opval);
1326 
    TRACE_RESULT (current_cpu, abuf, "dr-4", 'x', opval);
1327 
  }
1328 
  {
1329 
    BI opval = LTSI (GET_H_DR (((UINT) 5)), 0);
1330 
    CPU (h_nbit) = opval;
1331 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
1332 
  }
1333 
  {
1334 
    BI opval = EQDI (tmp_tmp, MAKEDI (0, 0));
1335 
    CPU (h_zbit) = opval;
1336 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
1337 
  }
1338 
  {
1339 
    BI opval = ORIF (GTDI (tmp_tmp, MAKEDI (0, 2147483647)), LTDI (tmp_tmp, NEGDI (MAKEDI (0, 0x80000000))));
1340 
    CPU (h_vbit) = opval;
1341 
    TRACE_RESULT (current_cpu, abuf, "vbit", 'x', opval);
1342 
  }
1343 
}
1344 
 
1345 
  return vpc;
1346 
#undef FLD
1347 
}
1348 
 
1349 
/* mulu: mulu $Rj,$Ri */
1350 
 
1351 
static SEM_PC
1352 
SEM_FN_NAME (fr30bf,mulu) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1353 
{
1354 
#define FLD(f) abuf->fields.sfmt_str13.f
1355 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1356 
  int UNUSED written = 0;
1357 
  IADDR UNUSED pc = abuf->addr;
1358 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1359 
 
1360 
{
1361 
  DI tmp_tmp;
1362 
  tmp_tmp = MULDI (ZEXTSIDI (* FLD (i_Rj)), ZEXTSIDI (* FLD (i_Ri)));
1363 
  {
1364 
    SI opval = TRUNCDISI (tmp_tmp);
1365 
    SET_H_DR (((UINT) 5), opval);
1366 
    TRACE_RESULT (current_cpu, abuf, "dr-5", 'x', opval);
1367 
  }
1368 
  {
1369 
    SI opval = TRUNCDISI (SRLDI (tmp_tmp, 32));
1370 
    SET_H_DR (((UINT) 4), opval);
1371 
    TRACE_RESULT (current_cpu, abuf, "dr-4", 'x', opval);
1372 
  }
1373 
  {
1374 
    BI opval = LTSI (GET_H_DR (((UINT) 4)), 0);
1375 
    CPU (h_nbit) = opval;
1376 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
1377 
  }
1378 
  {
1379 
    BI opval = EQSI (GET_H_DR (((UINT) 5)), 0);
1380 
    CPU (h_zbit) = opval;
1381 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
1382 
  }
1383 
  {
1384 
    BI opval = NESI (GET_H_DR (((UINT) 4)), 0);
1385 
    CPU (h_vbit) = opval;
1386 
    TRACE_RESULT (current_cpu, abuf, "vbit", 'x', opval);
1387 
  }
1388 
}
1389 
 
1390 
  return vpc;
1391 
#undef FLD
1392 
}
1393 
 
1394 
/* mulh: mulh $Rj,$Ri */
1395 
 
1396 
static SEM_PC
1397 
SEM_FN_NAME (fr30bf,mulh) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1398 
{
1399 
#define FLD(f) abuf->fields.sfmt_str13.f
1400 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1401 
  int UNUSED written = 0;
1402 
  IADDR UNUSED pc = abuf->addr;
1403 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1404 
 
1405 
{
1406 
  {
1407 
    SI opval = MULHI (TRUNCSIHI (* FLD (i_Rj)), TRUNCSIHI (* FLD (i_Ri)));
1408 
    SET_H_DR (((UINT) 5), opval);
1409 
    TRACE_RESULT (current_cpu, abuf, "dr-5", 'x', opval);
1410 
  }
1411 
  {
1412 
    BI opval = LTSI (GET_H_DR (((UINT) 5)), 0);
1413 
    CPU (h_nbit) = opval;
1414 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
1415 
  }
1416 
  {
1417 
    BI opval = GESI (GET_H_DR (((UINT) 5)), 0);
1418 
    CPU (h_zbit) = opval;
1419 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
1420 
  }
1421 
}
1422 
 
1423 
  return vpc;
1424 
#undef FLD
1425 
}
1426 
 
1427 
/* muluh: muluh $Rj,$Ri */
1428 
 
1429 
static SEM_PC
1430 
SEM_FN_NAME (fr30bf,muluh) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1431 
{
1432 
#define FLD(f) abuf->fields.sfmt_str13.f
1433 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1434 
  int UNUSED written = 0;
1435 
  IADDR UNUSED pc = abuf->addr;
1436 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1437 
 
1438 
{
1439 
  {
1440 
    SI opval = MULSI (ANDSI (* FLD (i_Rj), 65535), ANDSI (* FLD (i_Ri), 65535));
1441 
    SET_H_DR (((UINT) 5), opval);
1442 
    TRACE_RESULT (current_cpu, abuf, "dr-5", 'x', opval);
1443 
  }
1444 
  {
1445 
    BI opval = LTSI (GET_H_DR (((UINT) 5)), 0);
1446 
    CPU (h_nbit) = opval;
1447 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
1448 
  }
1449 
  {
1450 
    BI opval = GESI (GET_H_DR (((UINT) 5)), 0);
1451 
    CPU (h_zbit) = opval;
1452 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
1453 
  }
1454 
}
1455 
 
1456 
  return vpc;
1457 
#undef FLD
1458 
}
1459 
 
1460 
/* div0s: div0s $Ri */
1461 
 
1462 
static SEM_PC
1463 
SEM_FN_NAME (fr30bf,div0s) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1464 
{
1465 
#define FLD(f) abuf->fields.sfmt_mov2dr.f
1466 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1467 
  int UNUSED written = 0;
1468 
  IADDR UNUSED pc = abuf->addr;
1469 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1470 
 
1471 
{
1472 
  {
1473 
    BI opval = LTSI (GET_H_DR (((UINT) 5)), 0);
1474 
    CPU (h_d0bit) = opval;
1475 
    TRACE_RESULT (current_cpu, abuf, "d0bit", 'x', opval);
1476 
  }
1477 
  {
1478 
    BI opval = XORBI (CPU (h_d0bit), LTSI (* FLD (i_Ri), 0));
1479 
    CPU (h_d1bit) = opval;
1480 
    TRACE_RESULT (current_cpu, abuf, "d1bit", 'x', opval);
1481 
  }
1482 
if (NEBI (CPU (h_d0bit), 0)) {
1483 
  {
1484 
    SI opval = 0xffffffff;
1485 
    SET_H_DR (((UINT) 4), opval);
1486 
    written |= (1 << 5);
1487 
    TRACE_RESULT (current_cpu, abuf, "dr-4", 'x', opval);
1488 
  }
1489 
} else {
1490 
  {
1491 
    SI opval = 0;
1492 
    SET_H_DR (((UINT) 4), opval);
1493 
    written |= (1 << 5);
1494 
    TRACE_RESULT (current_cpu, abuf, "dr-4", 'x', opval);
1495 
  }
1496 
}
1497 
}
1498 
 
1499 
  abuf->written = written;
1500 
  return vpc;
1501 
#undef FLD
1502 
}
1503 
 
1504 
/* div0u: div0u $Ri */
1505 
 
1506 
static SEM_PC
1507 
SEM_FN_NAME (fr30bf,div0u) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1508 
{
1509 
#define FLD(f) abuf->fields.fmt_empty.f
1510 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1511 
  int UNUSED written = 0;
1512 
  IADDR UNUSED pc = abuf->addr;
1513 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1514 
 
1515 
{
1516 
  {
1517 
    BI opval = 0;
1518 
    CPU (h_d0bit) = opval;
1519 
    TRACE_RESULT (current_cpu, abuf, "d0bit", 'x', opval);
1520 
  }
1521 
  {
1522 
    BI opval = 0;
1523 
    CPU (h_d1bit) = opval;
1524 
    TRACE_RESULT (current_cpu, abuf, "d1bit", 'x', opval);
1525 
  }
1526 
  {
1527 
    SI opval = 0;
1528 
    SET_H_DR (((UINT) 4), opval);
1529 
    TRACE_RESULT (current_cpu, abuf, "dr-4", 'x', opval);
1530 
  }
1531 
}
1532 
 
1533 
  return vpc;
1534 
#undef FLD
1535 
}
1536 
 
1537 
/* div1: div1 $Ri */
1538 
 
1539 
static SEM_PC
1540 
SEM_FN_NAME (fr30bf,div1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1541 
{
1542 
#define FLD(f) abuf->fields.sfmt_mov2dr.f
1543 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1544 
  int UNUSED written = 0;
1545 
  IADDR UNUSED pc = abuf->addr;
1546 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1547 
 
1548 
{
1549 
  SI tmp_tmp;
1550 
  {
1551 
    SI opval = SLLSI (GET_H_DR (((UINT) 4)), 1);
1552 
    SET_H_DR (((UINT) 4), opval);
1553 
    TRACE_RESULT (current_cpu, abuf, "dr-4", 'x', opval);
1554 
  }
1555 
if (LTSI (GET_H_DR (((UINT) 5)), 0)) {
1556 
  {
1557 
    SI opval = ADDSI (GET_H_DR (((UINT) 4)), 1);
1558 
    SET_H_DR (((UINT) 4), opval);
1559 
    TRACE_RESULT (current_cpu, abuf, "dr-4", 'x', opval);
1560 
  }
1561 
}
1562 
  {
1563 
    SI opval = SLLSI (GET_H_DR (((UINT) 5)), 1);
1564 
    SET_H_DR (((UINT) 5), opval);
1565 
    TRACE_RESULT (current_cpu, abuf, "dr-5", 'x', opval);
1566 
  }
1567 
if (EQBI (CPU (h_d1bit), 1)) {
1568 
{
1569 
  tmp_tmp = ADDSI (GET_H_DR (((UINT) 4)), * FLD (i_Ri));
1570 
  {
1571 
    BI opval = ADDCFSI (GET_H_DR (((UINT) 4)), * FLD (i_Ri), 0);
1572 
    CPU (h_cbit) = opval;
1573 
    written |= (1 << 6);
1574 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
1575 
  }
1576 
}
1577 
} else {
1578 
{
1579 
  tmp_tmp = SUBSI (GET_H_DR (((UINT) 4)), * FLD (i_Ri));
1580 
  {
1581 
    BI opval = SUBCFSI (GET_H_DR (((UINT) 4)), * FLD (i_Ri), 0);
1582 
    CPU (h_cbit) = opval;
1583 
    written |= (1 << 6);
1584 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
1585 
  }
1586 
}
1587 
}
1588 
if (NOTBI (XORBI (XORBI (CPU (h_d0bit), CPU (h_d1bit)), CPU (h_cbit)))) {
1589 
{
1590 
  {
1591 
    SI opval = tmp_tmp;
1592 
    SET_H_DR (((UINT) 4), opval);
1593 
    TRACE_RESULT (current_cpu, abuf, "dr-4", 'x', opval);
1594 
  }
1595 
  {
1596 
    SI opval = ORSI (GET_H_DR (((UINT) 5)), 1);
1597 
    SET_H_DR (((UINT) 5), opval);
1598 
    TRACE_RESULT (current_cpu, abuf, "dr-5", 'x', opval);
1599 
  }
1600 
}
1601 
}
1602 
  {
1603 
    BI opval = EQSI (GET_H_DR (((UINT) 4)), 0);
1604 
    CPU (h_zbit) = opval;
1605 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
1606 
  }
1607 
}
1608 
 
1609 
  abuf->written = written;
1610 
  return vpc;
1611 
#undef FLD
1612 
}
1613 
 
1614 
/* div2: div2 $Ri */
1615 
 
1616 
static SEM_PC
1617 
SEM_FN_NAME (fr30bf,div2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1618 
{
1619 
#define FLD(f) abuf->fields.sfmt_mov2dr.f
1620 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1621 
  int UNUSED written = 0;
1622 
  IADDR UNUSED pc = abuf->addr;
1623 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1624 
 
1625 
{
1626 
  SI tmp_tmp;
1627 
if (EQBI (CPU (h_d1bit), 1)) {
1628 
{
1629 
  tmp_tmp = ADDSI (GET_H_DR (((UINT) 4)), * FLD (i_Ri));
1630 
  {
1631 
    BI opval = ADDCFSI (GET_H_DR (((UINT) 4)), * FLD (i_Ri), 0);
1632 
    CPU (h_cbit) = opval;
1633 
    written |= (1 << 3);
1634 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
1635 
  }
1636 
}
1637 
} else {
1638 
{
1639 
  tmp_tmp = SUBSI (GET_H_DR (((UINT) 4)), * FLD (i_Ri));
1640 
  {
1641 
    BI opval = SUBCFSI (GET_H_DR (((UINT) 4)), * FLD (i_Ri), 0);
1642 
    CPU (h_cbit) = opval;
1643 
    written |= (1 << 3);
1644 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
1645 
  }
1646 
}
1647 
}
1648 
if (EQSI (tmp_tmp, 0)) {
1649 
{
1650 
  {
1651 
    BI opval = 1;
1652 
    CPU (h_zbit) = opval;
1653 
    written |= (1 << 5);
1654 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
1655 
  }
1656 
  {
1657 
    SI opval = 0;
1658 
    SET_H_DR (((UINT) 4), opval);
1659 
    written |= (1 << 4);
1660 
    TRACE_RESULT (current_cpu, abuf, "dr-4", 'x', opval);
1661 
  }
1662 
}
1663 
} else {
1664 
  {
1665 
    BI opval = 0;
1666 
    CPU (h_zbit) = opval;
1667 
    written |= (1 << 5);
1668 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
1669 
  }
1670 
}
1671 
}
1672 
 
1673 
  abuf->written = written;
1674 
  return vpc;
1675 
#undef FLD
1676 
}
1677 
 
1678 
/* div3: div3 */
1679 
 
1680 
static SEM_PC
1681 
SEM_FN_NAME (fr30bf,div3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1682 
{
1683 
#define FLD(f) abuf->fields.fmt_empty.f
1684 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1685 
  int UNUSED written = 0;
1686 
  IADDR UNUSED pc = abuf->addr;
1687 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1688 
 
1689 
if (EQBI (CPU (h_zbit), 1)) {
1690 
  {
1691 
    SI opval = ADDSI (GET_H_DR (((UINT) 5)), 1);
1692 
    SET_H_DR (((UINT) 5), opval);
1693 
    written |= (1 << 2);
1694 
    TRACE_RESULT (current_cpu, abuf, "dr-5", 'x', opval);
1695 
  }
1696 
}
1697 
 
1698 
  abuf->written = written;
1699 
  return vpc;
1700 
#undef FLD
1701 
}
1702 
 
1703 
/* div4s: div4s */
1704 
 
1705 
static SEM_PC
1706 
SEM_FN_NAME (fr30bf,div4s) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1707 
{
1708 
#define FLD(f) abuf->fields.fmt_empty.f
1709 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1710 
  int UNUSED written = 0;
1711 
  IADDR UNUSED pc = abuf->addr;
1712 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1713 
 
1714 
if (EQBI (CPU (h_d1bit), 1)) {
1715 
  {
1716 
    SI opval = NEGSI (GET_H_DR (((UINT) 5)));
1717 
    SET_H_DR (((UINT) 5), opval);
1718 
    written |= (1 << 2);
1719 
    TRACE_RESULT (current_cpu, abuf, "dr-5", 'x', opval);
1720 
  }
1721 
}
1722 
 
1723 
  abuf->written = written;
1724 
  return vpc;
1725 
#undef FLD
1726 
}
1727 
 
1728 
/* lsl: lsl $Rj,$Ri */
1729 
 
1730 
static SEM_PC
1731 
SEM_FN_NAME (fr30bf,lsl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1732 
{
1733 
#define FLD(f) abuf->fields.sfmt_add.f
1734 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1735 
  int UNUSED written = 0;
1736 
  IADDR UNUSED pc = abuf->addr;
1737 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1738 
 
1739 
{
1740 
  SI tmp_shift;
1741 
  tmp_shift = ANDSI (* FLD (i_Rj), 31);
1742 
if (NESI (tmp_shift, 0)) {
1743 
{
1744 
  {
1745 
    BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (32, tmp_shift))), 0);
1746 
    CPU (h_cbit) = opval;
1747 
    written |= (1 << 3);
1748 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
1749 
  }
1750 
  {
1751 
    SI opval = SLLSI (* FLD (i_Ri), tmp_shift);
1752 
    * FLD (i_Ri) = opval;
1753 
    written |= (1 << 2);
1754 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
1755 
  }
1756 
}
1757 
} else {
1758 
  {
1759 
    BI opval = 0;
1760 
    CPU (h_cbit) = opval;
1761 
    written |= (1 << 3);
1762 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
1763 
  }
1764 
}
1765 
  {
1766 
    BI opval = LTSI (* FLD (i_Ri), 0);
1767 
    CPU (h_nbit) = opval;
1768 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
1769 
  }
1770 
  {
1771 
    BI opval = EQSI (* FLD (i_Ri), 0);
1772 
    CPU (h_zbit) = opval;
1773 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
1774 
  }
1775 
}
1776 
 
1777 
  abuf->written = written;
1778 
  return vpc;
1779 
#undef FLD
1780 
}
1781 
 
1782 
/* lsli: lsl $u4,$Ri */
1783 
 
1784 
static SEM_PC
1785 
SEM_FN_NAME (fr30bf,lsli) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1786 
{
1787 
#define FLD(f) abuf->fields.sfmt_addi.f
1788 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1789 
  int UNUSED written = 0;
1790 
  IADDR UNUSED pc = abuf->addr;
1791 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1792 
 
1793 
{
1794 
  SI tmp_shift;
1795 
  tmp_shift = FLD (f_u4);
1796 
if (NESI (tmp_shift, 0)) {
1797 
{
1798 
  {
1799 
    BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (32, tmp_shift))), 0);
1800 
    CPU (h_cbit) = opval;
1801 
    written |= (1 << 3);
1802 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
1803 
  }
1804 
  {
1805 
    SI opval = SLLSI (* FLD (i_Ri), tmp_shift);
1806 
    * FLD (i_Ri) = opval;
1807 
    written |= (1 << 2);
1808 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
1809 
  }
1810 
}
1811 
} else {
1812 
  {
1813 
    BI opval = 0;
1814 
    CPU (h_cbit) = opval;
1815 
    written |= (1 << 3);
1816 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
1817 
  }
1818 
}
1819 
  {
1820 
    BI opval = LTSI (* FLD (i_Ri), 0);
1821 
    CPU (h_nbit) = opval;
1822 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
1823 
  }
1824 
  {
1825 
    BI opval = EQSI (* FLD (i_Ri), 0);
1826 
    CPU (h_zbit) = opval;
1827 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
1828 
  }
1829 
}
1830 
 
1831 
  abuf->written = written;
1832 
  return vpc;
1833 
#undef FLD
1834 
}
1835 
 
1836 
/* lsl2: lsl2 $u4,$Ri */
1837 
 
1838 
static SEM_PC
1839 
SEM_FN_NAME (fr30bf,lsl2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1840 
{
1841 
#define FLD(f) abuf->fields.sfmt_addi.f
1842 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1843 
  int UNUSED written = 0;
1844 
  IADDR UNUSED pc = abuf->addr;
1845 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1846 
 
1847 
{
1848 
  SI tmp_shift;
1849 
  tmp_shift = ADDSI (FLD (f_u4), 16);
1850 
if (NESI (tmp_shift, 0)) {
1851 
{
1852 
  {
1853 
    BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (32, tmp_shift))), 0);
1854 
    CPU (h_cbit) = opval;
1855 
    written |= (1 << 3);
1856 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
1857 
  }
1858 
  {
1859 
    SI opval = SLLSI (* FLD (i_Ri), tmp_shift);
1860 
    * FLD (i_Ri) = opval;
1861 
    written |= (1 << 2);
1862 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
1863 
  }
1864 
}
1865 
} else {
1866 
  {
1867 
    BI opval = 0;
1868 
    CPU (h_cbit) = opval;
1869 
    written |= (1 << 3);
1870 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
1871 
  }
1872 
}
1873 
  {
1874 
    BI opval = LTSI (* FLD (i_Ri), 0);
1875 
    CPU (h_nbit) = opval;
1876 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
1877 
  }
1878 
  {
1879 
    BI opval = EQSI (* FLD (i_Ri), 0);
1880 
    CPU (h_zbit) = opval;
1881 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
1882 
  }
1883 
}
1884 
 
1885 
  abuf->written = written;
1886 
  return vpc;
1887 
#undef FLD
1888 
}
1889 
 
1890 
/* lsr: lsr $Rj,$Ri */
1891 
 
1892 
static SEM_PC
1893 
SEM_FN_NAME (fr30bf,lsr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1894 
{
1895 
#define FLD(f) abuf->fields.sfmt_add.f
1896 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1897 
  int UNUSED written = 0;
1898 
  IADDR UNUSED pc = abuf->addr;
1899 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1900 
 
1901 
{
1902 
  SI tmp_shift;
1903 
  tmp_shift = ANDSI (* FLD (i_Rj), 31);
1904 
if (NESI (tmp_shift, 0)) {
1905 
{
1906 
  {
1907 
    BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (tmp_shift, 1))), 0);
1908 
    CPU (h_cbit) = opval;
1909 
    written |= (1 << 3);
1910 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
1911 
  }
1912 
  {
1913 
    SI opval = SRLSI (* FLD (i_Ri), tmp_shift);
1914 
    * FLD (i_Ri) = opval;
1915 
    written |= (1 << 2);
1916 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
1917 
  }
1918 
}
1919 
} else {
1920 
  {
1921 
    BI opval = 0;
1922 
    CPU (h_cbit) = opval;
1923 
    written |= (1 << 3);
1924 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
1925 
  }
1926 
}
1927 
  {
1928 
    BI opval = LTSI (* FLD (i_Ri), 0);
1929 
    CPU (h_nbit) = opval;
1930 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
1931 
  }
1932 
  {
1933 
    BI opval = EQSI (* FLD (i_Ri), 0);
1934 
    CPU (h_zbit) = opval;
1935 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
1936 
  }
1937 
}
1938 
 
1939 
  abuf->written = written;
1940 
  return vpc;
1941 
#undef FLD
1942 
}
1943 
 
1944 
/* lsri: lsr $u4,$Ri */
1945 
 
1946 
static SEM_PC
1947 
SEM_FN_NAME (fr30bf,lsri) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1948 
{
1949 
#define FLD(f) abuf->fields.sfmt_addi.f
1950 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1951 
  int UNUSED written = 0;
1952 
  IADDR UNUSED pc = abuf->addr;
1953 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1954 
 
1955 
{
1956 
  SI tmp_shift;
1957 
  tmp_shift = FLD (f_u4);
1958 
if (NESI (tmp_shift, 0)) {
1959 
{
1960 
  {
1961 
    BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (tmp_shift, 1))), 0);
1962 
    CPU (h_cbit) = opval;
1963 
    written |= (1 << 3);
1964 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
1965 
  }
1966 
  {
1967 
    SI opval = SRLSI (* FLD (i_Ri), tmp_shift);
1968 
    * FLD (i_Ri) = opval;
1969 
    written |= (1 << 2);
1970 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
1971 
  }
1972 
}
1973 
} else {
1974 
  {
1975 
    BI opval = 0;
1976 
    CPU (h_cbit) = opval;
1977 
    written |= (1 << 3);
1978 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
1979 
  }
1980 
}
1981 
  {
1982 
    BI opval = LTSI (* FLD (i_Ri), 0);
1983 
    CPU (h_nbit) = opval;
1984 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
1985 
  }
1986 
  {
1987 
    BI opval = EQSI (* FLD (i_Ri), 0);
1988 
    CPU (h_zbit) = opval;
1989 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
1990 
  }
1991 
}
1992 
 
1993 
  abuf->written = written;
1994 
  return vpc;
1995 
#undef FLD
1996 
}
1997 
 
1998 
/* lsr2: lsr2 $u4,$Ri */
1999 
 
2000 
static SEM_PC
2001 
SEM_FN_NAME (fr30bf,lsr2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2002 
{
2003 
#define FLD(f) abuf->fields.sfmt_addi.f
2004 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2005 
  int UNUSED written = 0;
2006 
  IADDR UNUSED pc = abuf->addr;
2007 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2008 
 
2009 
{
2010 
  SI tmp_shift;
2011 
  tmp_shift = ADDSI (FLD (f_u4), 16);
2012 
if (NESI (tmp_shift, 0)) {
2013 
{
2014 
  {
2015 
    BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (tmp_shift, 1))), 0);
2016 
    CPU (h_cbit) = opval;
2017 
    written |= (1 << 3);
2018 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
2019 
  }
2020 
  {
2021 
    SI opval = SRLSI (* FLD (i_Ri), tmp_shift);
2022 
    * FLD (i_Ri) = opval;
2023 
    written |= (1 << 2);
2024 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
2025 
  }
2026 
}
2027 
} else {
2028 
  {
2029 
    BI opval = 0;
2030 
    CPU (h_cbit) = opval;
2031 
    written |= (1 << 3);
2032 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
2033 
  }
2034 
}
2035 
  {
2036 
    BI opval = LTSI (* FLD (i_Ri), 0);
2037 
    CPU (h_nbit) = opval;
2038 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
2039 
  }
2040 
  {
2041 
    BI opval = EQSI (* FLD (i_Ri), 0);
2042 
    CPU (h_zbit) = opval;
2043 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
2044 
  }
2045 
}
2046 
 
2047 
  abuf->written = written;
2048 
  return vpc;
2049 
#undef FLD
2050 
}
2051 
 
2052 
/* asr: asr $Rj,$Ri */
2053 
 
2054 
static SEM_PC
2055 
SEM_FN_NAME (fr30bf,asr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2056 
{
2057 
#define FLD(f) abuf->fields.sfmt_add.f
2058 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2059 
  int UNUSED written = 0;
2060 
  IADDR UNUSED pc = abuf->addr;
2061 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2062 
 
2063 
{
2064 
  SI tmp_shift;
2065 
  tmp_shift = ANDSI (* FLD (i_Rj), 31);
2066 
if (NESI (tmp_shift, 0)) {
2067 
{
2068 
  {
2069 
    BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (tmp_shift, 1))), 0);
2070 
    CPU (h_cbit) = opval;
2071 
    written |= (1 << 3);
2072 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
2073 
  }
2074 
  {
2075 
    SI opval = SRASI (* FLD (i_Ri), tmp_shift);
2076 
    * FLD (i_Ri) = opval;
2077 
    written |= (1 << 2);
2078 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
2079 
  }
2080 
}
2081 
} else {
2082 
  {
2083 
    BI opval = 0;
2084 
    CPU (h_cbit) = opval;
2085 
    written |= (1 << 3);
2086 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
2087 
  }
2088 
}
2089 
  {
2090 
    BI opval = LTSI (* FLD (i_Ri), 0);
2091 
    CPU (h_nbit) = opval;
2092 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
2093 
  }
2094 
  {
2095 
    BI opval = EQSI (* FLD (i_Ri), 0);
2096 
    CPU (h_zbit) = opval;
2097 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
2098 
  }
2099 
}
2100 
 
2101 
  abuf->written = written;
2102 
  return vpc;
2103 
#undef FLD
2104 
}
2105 
 
2106 
/* asri: asr $u4,$Ri */
2107 
 
2108 
static SEM_PC
2109 
SEM_FN_NAME (fr30bf,asri) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2110 
{
2111 
#define FLD(f) abuf->fields.sfmt_addi.f
2112 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2113 
  int UNUSED written = 0;
2114 
  IADDR UNUSED pc = abuf->addr;
2115 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2116 
 
2117 
{
2118 
  SI tmp_shift;
2119 
  tmp_shift = FLD (f_u4);
2120 
if (NESI (tmp_shift, 0)) {
2121 
{
2122 
  {
2123 
    BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (tmp_shift, 1))), 0);
2124 
    CPU (h_cbit) = opval;
2125 
    written |= (1 << 3);
2126 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
2127 
  }
2128 
  {
2129 
    SI opval = SRASI (* FLD (i_Ri), tmp_shift);
2130 
    * FLD (i_Ri) = opval;
2131 
    written |= (1 << 2);
2132 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
2133 
  }
2134 
}
2135 
} else {
2136 
  {
2137 
    BI opval = 0;
2138 
    CPU (h_cbit) = opval;
2139 
    written |= (1 << 3);
2140 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
2141 
  }
2142 
}
2143 
  {
2144 
    BI opval = LTSI (* FLD (i_Ri), 0);
2145 
    CPU (h_nbit) = opval;
2146 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
2147 
  }
2148 
  {
2149 
    BI opval = EQSI (* FLD (i_Ri), 0);
2150 
    CPU (h_zbit) = opval;
2151 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
2152 
  }
2153 
}
2154 
 
2155 
  abuf->written = written;
2156 
  return vpc;
2157 
#undef FLD
2158 
}
2159 
 
2160 
/* asr2: asr2 $u4,$Ri */
2161 
 
2162 
static SEM_PC
2163 
SEM_FN_NAME (fr30bf,asr2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2164 
{
2165 
#define FLD(f) abuf->fields.sfmt_addi.f
2166 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2167 
  int UNUSED written = 0;
2168 
  IADDR UNUSED pc = abuf->addr;
2169 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2170 
 
2171 
{
2172 
  SI tmp_shift;
2173 
  tmp_shift = ADDSI (FLD (f_u4), 16);
2174 
if (NESI (tmp_shift, 0)) {
2175 
{
2176 
  {
2177 
    BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (tmp_shift, 1))), 0);
2178 
    CPU (h_cbit) = opval;
2179 
    written |= (1 << 3);
2180 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
2181 
  }
2182 
  {
2183 
    SI opval = SRASI (* FLD (i_Ri), tmp_shift);
2184 
    * FLD (i_Ri) = opval;
2185 
    written |= (1 << 2);
2186 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
2187 
  }
2188 
}
2189 
} else {
2190 
  {
2191 
    BI opval = 0;
2192 
    CPU (h_cbit) = opval;
2193 
    written |= (1 << 3);
2194 
    TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
2195 
  }
2196 
}
2197 
  {
2198 
    BI opval = LTSI (* FLD (i_Ri), 0);
2199 
    CPU (h_nbit) = opval;
2200 
    TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
2201 
  }
2202 
  {
2203 
    BI opval = EQSI (* FLD (i_Ri), 0);
2204 
    CPU (h_zbit) = opval;
2205 
    TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
2206 
  }
2207 
}
2208 
 
2209 
  abuf->written = written;
2210 
  return vpc;
2211 
#undef FLD
2212 
}
2213 
 
2214 
/* ldi8: ldi:8 $i8,$Ri */
2215 
 
2216 
static SEM_PC
2217 
SEM_FN_NAME (fr30bf,ldi8) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2218 
{
2219 
#define FLD(f) abuf->fields.sfmt_ldi8.f
2220 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2221 
  int UNUSED written = 0;
2222 
  IADDR UNUSED pc = abuf->addr;
2223 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2224 
 
2225 
  {
2226 
    SI opval = FLD (f_i8);
2227 
    * FLD (i_Ri) = opval;
2228 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
2229 
  }
2230 
 
2231 
  return vpc;
2232 
#undef FLD
2233 
}
2234 
 
2235 
/* ldi20: ldi:20 $i20,$Ri */
2236 
 
2237 
static SEM_PC
2238 
SEM_FN_NAME (fr30bf,ldi20) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2239 
{
2240 
#define FLD(f) abuf->fields.sfmt_ldi20.f
2241 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2242 
  int UNUSED written = 0;
2243 
  IADDR UNUSED pc = abuf->addr;
2244 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2245 
 
2246 
  {
2247 
    SI opval = FLD (f_i20);
2248 
    * FLD (i_Ri) = opval;
2249 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
2250 
  }
2251 
 
2252 
  return vpc;
2253 
#undef FLD
2254 
}
2255 
 
2256 
/* ldi32: ldi:32 $i32,$Ri */
2257 
 
2258 
static SEM_PC
2259 
SEM_FN_NAME (fr30bf,ldi32) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2260 
{
2261 
#define FLD(f) abuf->fields.sfmt_ldi32.f
2262 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2263 
  int UNUSED written = 0;
2264 
  IADDR UNUSED pc = abuf->addr;
2265 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 6);
2266 
 
2267 
  {
2268 
    SI opval = FLD (f_i32);
2269 
    * FLD (i_Ri) = opval;
2270 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
2271 
  }
2272 
 
2273 
  return vpc;
2274 
#undef FLD
2275 
}
2276 
 
2277 
/* ld: ld @$Rj,$Ri */
2278 
 
2279 
static SEM_PC
2280 
SEM_FN_NAME (fr30bf,ld) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2281 
{
2282 
#define FLD(f) abuf->fields.sfmt_ldr13.f
2283 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2284 
  int UNUSED written = 0;
2285 
  IADDR UNUSED pc = abuf->addr;
2286 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2287 
 
2288 
  {
2289 
    SI opval = GETMEMSI (current_cpu, pc, * FLD (i_Rj));
2290 
    * FLD (i_Ri) = opval;
2291 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
2292 
  }
2293 
 
2294 
  return vpc;
2295 
#undef FLD
2296 
}
2297 
 
2298 
/* lduh: lduh @$Rj,$Ri */
2299 
 
2300 
static SEM_PC
2301 
SEM_FN_NAME (fr30bf,lduh) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2302 
{
2303 
#define FLD(f) abuf->fields.sfmt_ldr13.f
2304 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2305 
  int UNUSED written = 0;
2306 
  IADDR UNUSED pc = abuf->addr;
2307 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2308 
 
2309 
  {
2310 
    SI opval = GETMEMUHI (current_cpu, pc, * FLD (i_Rj));
2311 
    * FLD (i_Ri) = opval;
2312 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
2313 
  }
2314 
 
2315 
  return vpc;
2316 
#undef FLD
2317 
}
2318 
 
2319 
/* ldub: ldub @$Rj,$Ri */
2320 
 
2321 
static SEM_PC
2322 
SEM_FN_NAME (fr30bf,ldub) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2323 
{
2324 
#define FLD(f) abuf->fields.sfmt_ldr13.f
2325 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2326 
  int UNUSED written = 0;
2327 
  IADDR UNUSED pc = abuf->addr;
2328 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2329 
 
2330 
  {
2331 
    SI opval = GETMEMUQI (current_cpu, pc, * FLD (i_Rj));
2332 
    * FLD (i_Ri) = opval;
2333 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
2334 
  }
2335 
 
2336 
  return vpc;
2337 
#undef FLD
2338 
}
2339 
 
2340 
/* ldr13: ld @($R13,$Rj),$Ri */
2341 
 
2342 
static SEM_PC
2343 
SEM_FN_NAME (fr30bf,ldr13) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2344 
{
2345 
#define FLD(f) abuf->fields.sfmt_ldr13.f
2346 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2347 
  int UNUSED written = 0;
2348 
  IADDR UNUSED pc = abuf->addr;
2349 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2350 
 
2351 
  {
2352 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (* FLD (i_Rj), CPU (h_gr[((UINT) 13)])));
2353 
    * FLD (i_Ri) = opval;
2354 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
2355 
  }
2356 
 
2357 
  return vpc;
2358 
#undef FLD
2359 
}
2360 
 
2361 
/* ldr13uh: lduh @($R13,$Rj),$Ri */
2362 
 
2363 
static SEM_PC
2364 
SEM_FN_NAME (fr30bf,ldr13uh) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2365 
{
2366 
#define FLD(f) abuf->fields.sfmt_ldr13.f
2367 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2368 
  int UNUSED written = 0;
2369 
  IADDR UNUSED pc = abuf->addr;
2370 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2371 
 
2372 
  {
2373 
    SI opval = GETMEMUHI (current_cpu, pc, ADDSI (* FLD (i_Rj), CPU (h_gr[((UINT) 13)])));
2374 
    * FLD (i_Ri) = opval;
2375 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
2376 
  }
2377 
 
2378 
  return vpc;
2379 
#undef FLD
2380 
}
2381 
 
2382 
/* ldr13ub: ldub @($R13,$Rj),$Ri */
2383 
 
2384 
static SEM_PC
2385 
SEM_FN_NAME (fr30bf,ldr13ub) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2386 
{
2387 
#define FLD(f) abuf->fields.sfmt_ldr13.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, 2);
2392 
 
2393 
  {
2394 
    SI opval = GETMEMUQI (current_cpu, pc, ADDSI (* FLD (i_Rj), CPU (h_gr[((UINT) 13)])));
2395 
    * FLD (i_Ri) = opval;
2396 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
2397 
  }
2398 
 
2399 
  return vpc;
2400 
#undef FLD
2401 
}
2402 
 
2403 
/* ldr14: ld @($R14,$disp10),$Ri */
2404 
 
2405 
static SEM_PC
2406 
SEM_FN_NAME (fr30bf,ldr14) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2407 
{
2408 
#define FLD(f) abuf->fields.sfmt_ldr14.f
2409 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2410 
  int UNUSED written = 0;
2411 
  IADDR UNUSED pc = abuf->addr;
2412 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2413 
 
2414 
  {
2415 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (FLD (f_disp10), CPU (h_gr[((UINT) 14)])));
2416 
    * FLD (i_Ri) = opval;
2417 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
2418 
  }
2419 
 
2420 
  return vpc;
2421 
#undef FLD
2422 
}
2423 
 
2424 
/* ldr14uh: lduh @($R14,$disp9),$Ri */
2425 
 
2426 
static SEM_PC
2427 
SEM_FN_NAME (fr30bf,ldr14uh) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2428 
{
2429 
#define FLD(f) abuf->fields.sfmt_ldr14uh.f
2430 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2431 
  int UNUSED written = 0;
2432 
  IADDR UNUSED pc = abuf->addr;
2433 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2434 
 
2435 
  {
2436 
    SI opval = GETMEMUHI (current_cpu, pc, ADDSI (FLD (f_disp9), CPU (h_gr[((UINT) 14)])));
2437 
    * FLD (i_Ri) = opval;
2438 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
2439 
  }
2440 
 
2441 
  return vpc;
2442 
#undef FLD
2443 
}
2444 
 
2445 
/* ldr14ub: ldub @($R14,$disp8),$Ri */
2446 
 
2447 
static SEM_PC
2448 
SEM_FN_NAME (fr30bf,ldr14ub) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2449 
{
2450 
#define FLD(f) abuf->fields.sfmt_ldr14ub.f
2451 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2452 
  int UNUSED written = 0;
2453 
  IADDR UNUSED pc = abuf->addr;
2454 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2455 
 
2456 
  {
2457 
    SI opval = GETMEMUQI (current_cpu, pc, ADDSI (FLD (f_disp8), CPU (h_gr[((UINT) 14)])));
2458 
    * FLD (i_Ri) = opval;
2459 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
2460 
  }
2461 
 
2462 
  return vpc;
2463 
#undef FLD
2464 
}
2465 
 
2466 
/* ldr15: ld @($R15,$udisp6),$Ri */
2467 
 
2468 
static SEM_PC
2469 
SEM_FN_NAME (fr30bf,ldr15) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2470 
{
2471 
#define FLD(f) abuf->fields.sfmt_ldr15.f
2472 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2473 
  int UNUSED written = 0;
2474 
  IADDR UNUSED pc = abuf->addr;
2475 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2476 
 
2477 
  {
2478 
    SI opval = GETMEMSI (current_cpu, pc, ADDSI (FLD (f_udisp6), CPU (h_gr[((UINT) 15)])));
2479 
    * FLD (i_Ri) = opval;
2480 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
2481 
  }
2482 
 
2483 
  return vpc;
2484 
#undef FLD
2485 
}
2486 
 
2487 
/* ldr15gr: ld @$R15+,$Ri */
2488 
 
2489 
static SEM_PC
2490 
SEM_FN_NAME (fr30bf,ldr15gr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2491 
{
2492 
#define FLD(f) abuf->fields.sfmt_ldr15gr.f
2493 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2494 
  int UNUSED written = 0;
2495 
  IADDR UNUSED pc = abuf->addr;
2496 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2497 
 
2498 
{
2499 
  {
2500 
    SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
2501 
    * FLD (i_Ri) = opval;
2502 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
2503 
  }
2504 
if (NESI (FLD (f_Ri), 15)) {
2505 
  {
2506 
    SI opval = ADDSI (CPU (h_gr[((UINT) 15)]), 4);
2507 
    CPU (h_gr[((UINT) 15)]) = opval;
2508 
    written |= (1 << 4);
2509 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
2510 
  }
2511 
}
2512 
}
2513 
 
2514 
  abuf->written = written;
2515 
  return vpc;
2516 
#undef FLD
2517 
}
2518 
 
2519 
/* ldr15dr: ld @$R15+,$Rs2 */
2520 
 
2521 
static SEM_PC
2522 
SEM_FN_NAME (fr30bf,ldr15dr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2523 
{
2524 
#define FLD(f) abuf->fields.sfmt_ldr15dr.f
2525 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2526 
  int UNUSED written = 0;
2527 
  IADDR UNUSED pc = abuf->addr;
2528 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2529 
 
2530 
{
2531 
  SI tmp_tmp;
2532 
  tmp_tmp = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
2533 
  {
2534 
    SI opval = ADDSI (CPU (h_gr[((UINT) 15)]), 4);
2535 
    CPU (h_gr[((UINT) 15)]) = opval;
2536 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
2537 
  }
2538 
  {
2539 
    SI opval = tmp_tmp;
2540 
    SET_H_DR (FLD (f_Rs2), opval);
2541 
    TRACE_RESULT (current_cpu, abuf, "Rs2", 'x', opval);
2542 
  }
2543 
}
2544 
 
2545 
  return vpc;
2546 
#undef FLD
2547 
}
2548 
 
2549 
/* ldr15ps: ld @$R15+,$ps */
2550 
 
2551 
static SEM_PC
2552 
SEM_FN_NAME (fr30bf,ldr15ps) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2553 
{
2554 
#define FLD(f) abuf->fields.sfmt_addsp.f
2555 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2556 
  int UNUSED written = 0;
2557 
  IADDR UNUSED pc = abuf->addr;
2558 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2559 
 
2560 
{
2561 
  {
2562 
    USI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
2563 
    SET_H_PS (opval);
2564 
    TRACE_RESULT (current_cpu, abuf, "ps", 'x', opval);
2565 
  }
2566 
  {
2567 
    SI opval = ADDSI (CPU (h_gr[((UINT) 15)]), 4);
2568 
    CPU (h_gr[((UINT) 15)]) = opval;
2569 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
2570 
  }
2571 
}
2572 
 
2573 
  return vpc;
2574 
#undef FLD
2575 
}
2576 
 
2577 
/* st: st $Ri,@$Rj */
2578 
 
2579 
static SEM_PC
2580 
SEM_FN_NAME (fr30bf,st) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2581 
{
2582 
#define FLD(f) abuf->fields.sfmt_str13.f
2583 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2584 
  int UNUSED written = 0;
2585 
  IADDR UNUSED pc = abuf->addr;
2586 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2587 
 
2588 
  {
2589 
    SI opval = * FLD (i_Ri);
2590 
    SETMEMSI (current_cpu, pc, * FLD (i_Rj), opval);
2591 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2592 
  }
2593 
 
2594 
  return vpc;
2595 
#undef FLD
2596 
}
2597 
 
2598 
/* sth: sth $Ri,@$Rj */
2599 
 
2600 
static SEM_PC
2601 
SEM_FN_NAME (fr30bf,sth) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2602 
{
2603 
#define FLD(f) abuf->fields.sfmt_str13.f
2604 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2605 
  int UNUSED written = 0;
2606 
  IADDR UNUSED pc = abuf->addr;
2607 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2608 
 
2609 
  {
2610 
    HI opval = * FLD (i_Ri);
2611 
    SETMEMHI (current_cpu, pc, * FLD (i_Rj), opval);
2612 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2613 
  }
2614 
 
2615 
  return vpc;
2616 
#undef FLD
2617 
}
2618 
 
2619 
/* stb: stb $Ri,@$Rj */
2620 
 
2621 
static SEM_PC
2622 
SEM_FN_NAME (fr30bf,stb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2623 
{
2624 
#define FLD(f) abuf->fields.sfmt_str13.f
2625 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2626 
  int UNUSED written = 0;
2627 
  IADDR UNUSED pc = abuf->addr;
2628 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2629 
 
2630 
  {
2631 
    QI opval = * FLD (i_Ri);
2632 
    SETMEMQI (current_cpu, pc, * FLD (i_Rj), opval);
2633 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2634 
  }
2635 
 
2636 
  return vpc;
2637 
#undef FLD
2638 
}
2639 
 
2640 
/* str13: st $Ri,@($R13,$Rj) */
2641 
 
2642 
static SEM_PC
2643 
SEM_FN_NAME (fr30bf,str13) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2644 
{
2645 
#define FLD(f) abuf->fields.sfmt_str13.f
2646 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2647 
  int UNUSED written = 0;
2648 
  IADDR UNUSED pc = abuf->addr;
2649 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2650 
 
2651 
  {
2652 
    SI opval = * FLD (i_Ri);
2653 
    SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_Rj), CPU (h_gr[((UINT) 13)])), opval);
2654 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2655 
  }
2656 
 
2657 
  return vpc;
2658 
#undef FLD
2659 
}
2660 
 
2661 
/* str13h: sth $Ri,@($R13,$Rj) */
2662 
 
2663 
static SEM_PC
2664 
SEM_FN_NAME (fr30bf,str13h) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2665 
{
2666 
#define FLD(f) abuf->fields.sfmt_str13.f
2667 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2668 
  int UNUSED written = 0;
2669 
  IADDR UNUSED pc = abuf->addr;
2670 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2671 
 
2672 
  {
2673 
    HI opval = * FLD (i_Ri);
2674 
    SETMEMHI (current_cpu, pc, ADDSI (* FLD (i_Rj), CPU (h_gr[((UINT) 13)])), opval);
2675 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2676 
  }
2677 
 
2678 
  return vpc;
2679 
#undef FLD
2680 
}
2681 
 
2682 
/* str13b: stb $Ri,@($R13,$Rj) */
2683 
 
2684 
static SEM_PC
2685 
SEM_FN_NAME (fr30bf,str13b) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2686 
{
2687 
#define FLD(f) abuf->fields.sfmt_str13.f
2688 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2689 
  int UNUSED written = 0;
2690 
  IADDR UNUSED pc = abuf->addr;
2691 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2692 
 
2693 
  {
2694 
    QI opval = * FLD (i_Ri);
2695 
    SETMEMQI (current_cpu, pc, ADDSI (* FLD (i_Rj), CPU (h_gr[((UINT) 13)])), opval);
2696 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2697 
  }
2698 
 
2699 
  return vpc;
2700 
#undef FLD
2701 
}
2702 
 
2703 
/* str14: st $Ri,@($R14,$disp10) */
2704 
 
2705 
static SEM_PC
2706 
SEM_FN_NAME (fr30bf,str14) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2707 
{
2708 
#define FLD(f) abuf->fields.sfmt_str14.f
2709 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2710 
  int UNUSED written = 0;
2711 
  IADDR UNUSED pc = abuf->addr;
2712 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2713 
 
2714 
  {
2715 
    SI opval = * FLD (i_Ri);
2716 
    SETMEMSI (current_cpu, pc, ADDSI (FLD (f_disp10), CPU (h_gr[((UINT) 14)])), opval);
2717 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2718 
  }
2719 
 
2720 
  return vpc;
2721 
#undef FLD
2722 
}
2723 
 
2724 
/* str14h: sth $Ri,@($R14,$disp9) */
2725 
 
2726 
static SEM_PC
2727 
SEM_FN_NAME (fr30bf,str14h) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2728 
{
2729 
#define FLD(f) abuf->fields.sfmt_str14h.f
2730 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2731 
  int UNUSED written = 0;
2732 
  IADDR UNUSED pc = abuf->addr;
2733 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2734 
 
2735 
  {
2736 
    HI opval = * FLD (i_Ri);
2737 
    SETMEMHI (current_cpu, pc, ADDSI (FLD (f_disp9), CPU (h_gr[((UINT) 14)])), opval);
2738 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2739 
  }
2740 
 
2741 
  return vpc;
2742 
#undef FLD
2743 
}
2744 
 
2745 
/* str14b: stb $Ri,@($R14,$disp8) */
2746 
 
2747 
static SEM_PC
2748 
SEM_FN_NAME (fr30bf,str14b) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2749 
{
2750 
#define FLD(f) abuf->fields.sfmt_str14b.f
2751 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2752 
  int UNUSED written = 0;
2753 
  IADDR UNUSED pc = abuf->addr;
2754 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2755 
 
2756 
  {
2757 
    QI opval = * FLD (i_Ri);
2758 
    SETMEMQI (current_cpu, pc, ADDSI (FLD (f_disp8), CPU (h_gr[((UINT) 14)])), opval);
2759 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2760 
  }
2761 
 
2762 
  return vpc;
2763 
#undef FLD
2764 
}
2765 
 
2766 
/* str15: st $Ri,@($R15,$udisp6) */
2767 
 
2768 
static SEM_PC
2769 
SEM_FN_NAME (fr30bf,str15) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2770 
{
2771 
#define FLD(f) abuf->fields.sfmt_str15.f
2772 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2773 
  int UNUSED written = 0;
2774 
  IADDR UNUSED pc = abuf->addr;
2775 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2776 
 
2777 
  {
2778 
    SI opval = * FLD (i_Ri);
2779 
    SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 15)]), FLD (f_udisp6)), opval);
2780 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2781 
  }
2782 
 
2783 
  return vpc;
2784 
#undef FLD
2785 
}
2786 
 
2787 
/* str15gr: st $Ri,@-$R15 */
2788 
 
2789 
static SEM_PC
2790 
SEM_FN_NAME (fr30bf,str15gr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2791 
{
2792 
#define FLD(f) abuf->fields.sfmt_str15gr.f
2793 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2794 
  int UNUSED written = 0;
2795 
  IADDR UNUSED pc = abuf->addr;
2796 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2797 
 
2798 
{
2799 
  SI tmp_tmp;
2800 
  tmp_tmp = * FLD (i_Ri);
2801 
  {
2802 
    SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
2803 
    CPU (h_gr[((UINT) 15)]) = opval;
2804 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
2805 
  }
2806 
  {
2807 
    SI opval = tmp_tmp;
2808 
    SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
2809 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2810 
  }
2811 
}
2812 
 
2813 
  return vpc;
2814 
#undef FLD
2815 
}
2816 
 
2817 
/* str15dr: st $Rs2,@-$R15 */
2818 
 
2819 
static SEM_PC
2820 
SEM_FN_NAME (fr30bf,str15dr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2821 
{
2822 
#define FLD(f) abuf->fields.sfmt_ldr15dr.f
2823 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2824 
  int UNUSED written = 0;
2825 
  IADDR UNUSED pc = abuf->addr;
2826 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2827 
 
2828 
{
2829 
  SI tmp_tmp;
2830 
  tmp_tmp = GET_H_DR (FLD (f_Rs2));
2831 
  {
2832 
    SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
2833 
    CPU (h_gr[((UINT) 15)]) = opval;
2834 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
2835 
  }
2836 
  {
2837 
    SI opval = tmp_tmp;
2838 
    SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
2839 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2840 
  }
2841 
}
2842 
 
2843 
  return vpc;
2844 
#undef FLD
2845 
}
2846 
 
2847 
/* str15ps: st $ps,@-$R15 */
2848 
 
2849 
static SEM_PC
2850 
SEM_FN_NAME (fr30bf,str15ps) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2851 
{
2852 
#define FLD(f) abuf->fields.sfmt_addsp.f
2853 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2854 
  int UNUSED written = 0;
2855 
  IADDR UNUSED pc = abuf->addr;
2856 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2857 
 
2858 
{
2859 
  {
2860 
    SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
2861 
    CPU (h_gr[((UINT) 15)]) = opval;
2862 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
2863 
  }
2864 
  {
2865 
    SI opval = GET_H_PS ();
2866 
    SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
2867 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2868 
  }
2869 
}
2870 
 
2871 
  return vpc;
2872 
#undef FLD
2873 
}
2874 
 
2875 
/* mov: mov $Rj,$Ri */
2876 
 
2877 
static SEM_PC
2878 
SEM_FN_NAME (fr30bf,mov) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2879 
{
2880 
#define FLD(f) abuf->fields.sfmt_ldr13.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, 2);
2885 
 
2886 
  {
2887 
    SI opval = * FLD (i_Rj);
2888 
    * FLD (i_Ri) = opval;
2889 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
2890 
  }
2891 
 
2892 
  return vpc;
2893 
#undef FLD
2894 
}
2895 
 
2896 
/* movdr: mov $Rs1,$Ri */
2897 
 
2898 
static SEM_PC
2899 
SEM_FN_NAME (fr30bf,movdr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2900 
{
2901 
#define FLD(f) abuf->fields.sfmt_movdr.f
2902 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2903 
  int UNUSED written = 0;
2904 
  IADDR UNUSED pc = abuf->addr;
2905 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2906 
 
2907 
  {
2908 
    SI opval = GET_H_DR (FLD (f_Rs1));
2909 
    * FLD (i_Ri) = opval;
2910 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
2911 
  }
2912 
 
2913 
  return vpc;
2914 
#undef FLD
2915 
}
2916 
 
2917 
/* movps: mov $ps,$Ri */
2918 
 
2919 
static SEM_PC
2920 
SEM_FN_NAME (fr30bf,movps) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2921 
{
2922 
#define FLD(f) abuf->fields.sfmt_movdr.f
2923 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2924 
  int UNUSED written = 0;
2925 
  IADDR UNUSED pc = abuf->addr;
2926 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2927 
 
2928 
  {
2929 
    SI opval = GET_H_PS ();
2930 
    * FLD (i_Ri) = opval;
2931 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
2932 
  }
2933 
 
2934 
  return vpc;
2935 
#undef FLD
2936 
}
2937 
 
2938 
/* mov2dr: mov $Ri,$Rs1 */
2939 
 
2940 
static SEM_PC
2941 
SEM_FN_NAME (fr30bf,mov2dr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2942 
{
2943 
#define FLD(f) abuf->fields.sfmt_mov2dr.f
2944 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2945 
  int UNUSED written = 0;
2946 
  IADDR UNUSED pc = abuf->addr;
2947 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2948 
 
2949 
  {
2950 
    SI opval = * FLD (i_Ri);
2951 
    SET_H_DR (FLD (f_Rs1), opval);
2952 
    TRACE_RESULT (current_cpu, abuf, "Rs1", 'x', opval);
2953 
  }
2954 
 
2955 
  return vpc;
2956 
#undef FLD
2957 
}
2958 
 
2959 
/* mov2ps: mov $Ri,$ps */
2960 
 
2961 
static SEM_PC
2962 
SEM_FN_NAME (fr30bf,mov2ps) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2963 
{
2964 
#define FLD(f) abuf->fields.sfmt_mov2dr.f
2965 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2966 
  int UNUSED written = 0;
2967 
  IADDR UNUSED pc = abuf->addr;
2968 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2969 
 
2970 
  {
2971 
    USI opval = * FLD (i_Ri);
2972 
    SET_H_PS (opval);
2973 
    TRACE_RESULT (current_cpu, abuf, "ps", 'x', opval);
2974 
  }
2975 
 
2976 
  return vpc;
2977 
#undef FLD
2978 
}
2979 
 
2980 
/* jmp: jmp @$Ri */
2981 
 
2982 
static SEM_PC
2983 
SEM_FN_NAME (fr30bf,jmp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2984 
{
2985 
#define FLD(f) abuf->fields.sfmt_mov2dr.f
2986 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2987 
  int UNUSED written = 0;
2988 
  IADDR UNUSED pc = abuf->addr;
2989 
  SEM_BRANCH_INIT
2990 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2991 
 
2992 
  {
2993 
    USI opval = * FLD (i_Ri);
2994 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
2995 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
2996 
  }
2997 
 
2998 
  SEM_BRANCH_FINI (vpc);
2999 
  return vpc;
3000 
#undef FLD
3001 
}
3002 
 
3003 
/* jmpd: jmp:d @$Ri */
3004 
 
3005 
static SEM_PC
3006 
SEM_FN_NAME (fr30bf,jmpd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3007 
{
3008 
#define FLD(f) abuf->fields.sfmt_mov2dr.f
3009 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3010 
  int UNUSED written = 0;
3011 
  IADDR UNUSED pc = abuf->addr;
3012 
  SEM_BRANCH_INIT
3013 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3014 
 
3015 
{
3016 
  {
3017 
    USI opval = * FLD (i_Ri);
3018 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
3019 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3020 
  }
3021 
}
3022 
 
3023 
  SEM_BRANCH_FINI (vpc);
3024 
  return vpc;
3025 
#undef FLD
3026 
}
3027 
 
3028 
/* callr: call @$Ri */
3029 
 
3030 
static SEM_PC
3031 
SEM_FN_NAME (fr30bf,callr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3032 
{
3033 
#define FLD(f) abuf->fields.sfmt_mov2dr.f
3034 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3035 
  int UNUSED written = 0;
3036 
  IADDR UNUSED pc = abuf->addr;
3037 
  SEM_BRANCH_INIT
3038 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3039 
 
3040 
{
3041 
  {
3042 
    SI opval = ADDSI (pc, 2);
3043 
    SET_H_DR (((UINT) 1), opval);
3044 
    TRACE_RESULT (current_cpu, abuf, "dr-1", 'x', opval);
3045 
  }
3046 
  {
3047 
    USI opval = * FLD (i_Ri);
3048 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
3049 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3050 
  }
3051 
}
3052 
 
3053 
  SEM_BRANCH_FINI (vpc);
3054 
  return vpc;
3055 
#undef FLD
3056 
}
3057 
 
3058 
/* callrd: call:d @$Ri */
3059 
 
3060 
static SEM_PC
3061 
SEM_FN_NAME (fr30bf,callrd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3062 
{
3063 
#define FLD(f) abuf->fields.sfmt_mov2dr.f
3064 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3065 
  int UNUSED written = 0;
3066 
  IADDR UNUSED pc = abuf->addr;
3067 
  SEM_BRANCH_INIT
3068 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3069 
 
3070 
{
3071 
{
3072 
  {
3073 
    SI opval = ADDSI (pc, 4);
3074 
    SET_H_DR (((UINT) 1), opval);
3075 
    TRACE_RESULT (current_cpu, abuf, "dr-1", 'x', opval);
3076 
  }
3077 
  {
3078 
    USI opval = * FLD (i_Ri);
3079 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
3080 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3081 
  }
3082 
}
3083 
}
3084 
 
3085 
  SEM_BRANCH_FINI (vpc);
3086 
  return vpc;
3087 
#undef FLD
3088 
}
3089 
 
3090 
/* call: call $label12 */
3091 
 
3092 
static SEM_PC
3093 
SEM_FN_NAME (fr30bf,call) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3094 
{
3095 
#define FLD(f) abuf->fields.sfmt_call.f
3096 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3097 
  int UNUSED written = 0;
3098 
  IADDR UNUSED pc = abuf->addr;
3099 
  SEM_BRANCH_INIT
3100 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3101 
 
3102 
{
3103 
  {
3104 
    SI opval = ADDSI (pc, 2);
3105 
    SET_H_DR (((UINT) 1), opval);
3106 
    TRACE_RESULT (current_cpu, abuf, "dr-1", 'x', opval);
3107 
  }
3108 
  {
3109 
    USI opval = FLD (i_label12);
3110 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3111 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3112 
  }
3113 
}
3114 
 
3115 
  SEM_BRANCH_FINI (vpc);
3116 
  return vpc;
3117 
#undef FLD
3118 
}
3119 
 
3120 
/* calld: call:d $label12 */
3121 
 
3122 
static SEM_PC
3123 
SEM_FN_NAME (fr30bf,calld) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3124 
{
3125 
#define FLD(f) abuf->fields.sfmt_call.f
3126 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3127 
  int UNUSED written = 0;
3128 
  IADDR UNUSED pc = abuf->addr;
3129 
  SEM_BRANCH_INIT
3130 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3131 
 
3132 
{
3133 
{
3134 
  {
3135 
    SI opval = ADDSI (pc, 4);
3136 
    SET_H_DR (((UINT) 1), opval);
3137 
    TRACE_RESULT (current_cpu, abuf, "dr-1", 'x', opval);
3138 
  }
3139 
  {
3140 
    USI opval = FLD (i_label12);
3141 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3142 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3143 
  }
3144 
}
3145 
}
3146 
 
3147 
  SEM_BRANCH_FINI (vpc);
3148 
  return vpc;
3149 
#undef FLD
3150 
}
3151 
 
3152 
/* ret: ret */
3153 
 
3154 
static SEM_PC
3155 
SEM_FN_NAME (fr30bf,ret) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3156 
{
3157 
#define FLD(f) abuf->fields.fmt_empty.f
3158 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3159 
  int UNUSED written = 0;
3160 
  IADDR UNUSED pc = abuf->addr;
3161 
  SEM_BRANCH_INIT
3162 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3163 
 
3164 
  {
3165 
    USI opval = GET_H_DR (((UINT) 1));
3166 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
3167 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3168 
  }
3169 
 
3170 
  SEM_BRANCH_FINI (vpc);
3171 
  return vpc;
3172 
#undef FLD
3173 
}
3174 
 
3175 
/* ret:d: ret:d */
3176 
 
3177 
static SEM_PC
3178 
SEM_FN_NAME (fr30bf,ret_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3179 
{
3180 
#define FLD(f) abuf->fields.fmt_empty.f
3181 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3182 
  int UNUSED written = 0;
3183 
  IADDR UNUSED pc = abuf->addr;
3184 
  SEM_BRANCH_INIT
3185 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3186 
 
3187 
{
3188 
  {
3189 
    USI opval = GET_H_DR (((UINT) 1));
3190 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
3191 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3192 
  }
3193 
}
3194 
 
3195 
  SEM_BRANCH_FINI (vpc);
3196 
  return vpc;
3197 
#undef FLD
3198 
}
3199 
 
3200 
/* int: int $u8 */
3201 
 
3202 
static SEM_PC
3203 
SEM_FN_NAME (fr30bf,int) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3204 
{
3205 
#define FLD(f) abuf->fields.sfmt_int.f
3206 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3207 
  int UNUSED written = 0;
3208 
  IADDR UNUSED pc = abuf->addr;
3209 
  SEM_BRANCH_INIT
3210 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3211 
 
3212 
{
3213 
; /*clobber*/
3214 
; /*clobber*/
3215 
; /*clobber*/
3216 
  {
3217 
    SI opval = fr30_int (current_cpu, pc, FLD (f_u8));
3218 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
3219 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3220 
  }
3221 
}
3222 
 
3223 
  SEM_BRANCH_FINI (vpc);
3224 
  return vpc;
3225 
#undef FLD
3226 
}
3227 
 
3228 
/* inte: inte */
3229 
 
3230 
static SEM_PC
3231 
SEM_FN_NAME (fr30bf,inte) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3232 
{
3233 
#define FLD(f) abuf->fields.fmt_empty.f
3234 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3235 
  int UNUSED written = 0;
3236 
  IADDR UNUSED pc = abuf->addr;
3237 
  SEM_BRANCH_INIT
3238 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3239 
 
3240 
{
3241 
; /*clobber*/
3242 
; /*clobber*/
3243 
; /*clobber*/
3244 
  {
3245 
    SI opval = fr30_inte (current_cpu, pc);
3246 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
3247 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3248 
  }
3249 
}
3250 
 
3251 
  SEM_BRANCH_FINI (vpc);
3252 
  return vpc;
3253 
#undef FLD
3254 
}
3255 
 
3256 
/* reti: reti */
3257 
 
3258 
static SEM_PC
3259 
SEM_FN_NAME (fr30bf,reti) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3260 
{
3261 
#define FLD(f) abuf->fields.fmt_empty.f
3262 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3263 
  int UNUSED written = 0;
3264 
  IADDR UNUSED pc = abuf->addr;
3265 
  SEM_BRANCH_INIT
3266 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3267 
 
3268 
if (EQBI (GET_H_SBIT (), 0)) {
3269 
{
3270 
  {
3271 
    SI opval = GETMEMSI (current_cpu, pc, GET_H_DR (((UINT) 2)));
3272 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
3273 
    written |= (1 << 7);
3274 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3275 
  }
3276 
  {
3277 
    SI opval = ADDSI (GET_H_DR (((UINT) 2)), 4);
3278 
    SET_H_DR (((UINT) 2), opval);
3279 
    written |= (1 << 5);
3280 
    TRACE_RESULT (current_cpu, abuf, "dr-2", 'x', opval);
3281 
  }
3282 
  {
3283 
    SI opval = GETMEMSI (current_cpu, pc, GET_H_DR (((UINT) 2)));
3284 
    SET_H_PS (opval);
3285 
    written |= (1 << 8);
3286 
    TRACE_RESULT (current_cpu, abuf, "ps", 'x', opval);
3287 
  }
3288 
  {
3289 
    SI opval = ADDSI (GET_H_DR (((UINT) 2)), 4);
3290 
    SET_H_DR (((UINT) 2), opval);
3291 
    written |= (1 << 5);
3292 
    TRACE_RESULT (current_cpu, abuf, "dr-2", 'x', opval);
3293 
  }
3294 
}
3295 
} else {
3296 
{
3297 
  {
3298 
    SI opval = GETMEMSI (current_cpu, pc, GET_H_DR (((UINT) 3)));
3299 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
3300 
    written |= (1 << 7);
3301 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3302 
  }
3303 
  {
3304 
    SI opval = ADDSI (GET_H_DR (((UINT) 3)), 4);
3305 
    SET_H_DR (((UINT) 3), opval);
3306 
    written |= (1 << 6);
3307 
    TRACE_RESULT (current_cpu, abuf, "dr-3", 'x', opval);
3308 
  }
3309 
  {
3310 
    SI opval = GETMEMSI (current_cpu, pc, GET_H_DR (((UINT) 3)));
3311 
    SET_H_PS (opval);
3312 
    written |= (1 << 8);
3313 
    TRACE_RESULT (current_cpu, abuf, "ps", 'x', opval);
3314 
  }
3315 
  {
3316 
    SI opval = ADDSI (GET_H_DR (((UINT) 3)), 4);
3317 
    SET_H_DR (((UINT) 3), opval);
3318 
    written |= (1 << 6);
3319 
    TRACE_RESULT (current_cpu, abuf, "dr-3", 'x', opval);
3320 
  }
3321 
}
3322 
}
3323 
 
3324 
  abuf->written = written;
3325 
  SEM_BRANCH_FINI (vpc);
3326 
  return vpc;
3327 
#undef FLD
3328 
}
3329 
 
3330 
/* brad: bra:d $label9 */
3331 
 
3332 
static SEM_PC
3333 
SEM_FN_NAME (fr30bf,brad) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3334 
{
3335 
#define FLD(f) abuf->fields.sfmt_brad.f
3336 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3337 
  int UNUSED written = 0;
3338 
  IADDR UNUSED pc = abuf->addr;
3339 
  SEM_BRANCH_INIT
3340 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3341 
 
3342 
{
3343 
  {
3344 
    USI opval = FLD (i_label9);
3345 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3346 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3347 
  }
3348 
}
3349 
 
3350 
  SEM_BRANCH_FINI (vpc);
3351 
  return vpc;
3352 
#undef FLD
3353 
}
3354 
 
3355 
/* bra: bra $label9 */
3356 
 
3357 
static SEM_PC
3358 
SEM_FN_NAME (fr30bf,bra) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3359 
{
3360 
#define FLD(f) abuf->fields.sfmt_brad.f
3361 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3362 
  int UNUSED written = 0;
3363 
  IADDR UNUSED pc = abuf->addr;
3364 
  SEM_BRANCH_INIT
3365 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3366 
 
3367 
  {
3368 
    USI opval = FLD (i_label9);
3369 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3370 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3371 
  }
3372 
 
3373 
  SEM_BRANCH_FINI (vpc);
3374 
  return vpc;
3375 
#undef FLD
3376 
}
3377 
 
3378 
/* bnod: bno:d $label9 */
3379 
 
3380 
static SEM_PC
3381 
SEM_FN_NAME (fr30bf,bnod) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3382 
{
3383 
#define FLD(f) abuf->fields.fmt_empty.f
3384 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3385 
  int UNUSED written = 0;
3386 
  IADDR UNUSED pc = abuf->addr;
3387 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3388 
 
3389 
{
3390 
((void) 0); /*nop*/
3391 
}
3392 
 
3393 
  return vpc;
3394 
#undef FLD
3395 
}
3396 
 
3397 
/* bno: bno $label9 */
3398 
 
3399 
static SEM_PC
3400 
SEM_FN_NAME (fr30bf,bno) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3401 
{
3402 
#define FLD(f) abuf->fields.fmt_empty.f
3403 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3404 
  int UNUSED written = 0;
3405 
  IADDR UNUSED pc = abuf->addr;
3406 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3407 
 
3408 
((void) 0); /*nop*/
3409 
 
3410 
  return vpc;
3411 
#undef FLD
3412 
}
3413 
 
3414 
/* beqd: beq:d $label9 */
3415 
 
3416 
static SEM_PC
3417 
SEM_FN_NAME (fr30bf,beqd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3418 
{
3419 
#define FLD(f) abuf->fields.sfmt_brad.f
3420 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3421 
  int UNUSED written = 0;
3422 
  IADDR UNUSED pc = abuf->addr;
3423 
  SEM_BRANCH_INIT
3424 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3425 
 
3426 
{
3427 
if (CPU (h_zbit)) {
3428 
  {
3429 
    USI opval = FLD (i_label9);
3430 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3431 
    written |= (1 << 2);
3432 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3433 
  }
3434 
}
3435 
}
3436 
 
3437 
  abuf->written = written;
3438 
  SEM_BRANCH_FINI (vpc);
3439 
  return vpc;
3440 
#undef FLD
3441 
}
3442 
 
3443 
/* beq: beq $label9 */
3444 
 
3445 
static SEM_PC
3446 
SEM_FN_NAME (fr30bf,beq) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3447 
{
3448 
#define FLD(f) abuf->fields.sfmt_brad.f
3449 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3450 
  int UNUSED written = 0;
3451 
  IADDR UNUSED pc = abuf->addr;
3452 
  SEM_BRANCH_INIT
3453 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3454 
 
3455 
if (CPU (h_zbit)) {
3456 
  {
3457 
    USI opval = FLD (i_label9);
3458 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3459 
    written |= (1 << 2);
3460 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3461 
  }
3462 
}
3463 
 
3464 
  abuf->written = written;
3465 
  SEM_BRANCH_FINI (vpc);
3466 
  return vpc;
3467 
#undef FLD
3468 
}
3469 
 
3470 
/* bned: bne:d $label9 */
3471 
 
3472 
static SEM_PC
3473 
SEM_FN_NAME (fr30bf,bned) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3474 
{
3475 
#define FLD(f) abuf->fields.sfmt_brad.f
3476 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3477 
  int UNUSED written = 0;
3478 
  IADDR UNUSED pc = abuf->addr;
3479 
  SEM_BRANCH_INIT
3480 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3481 
 
3482 
{
3483 
if (NOTBI (CPU (h_zbit))) {
3484 
  {
3485 
    USI opval = FLD (i_label9);
3486 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3487 
    written |= (1 << 2);
3488 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3489 
  }
3490 
}
3491 
}
3492 
 
3493 
  abuf->written = written;
3494 
  SEM_BRANCH_FINI (vpc);
3495 
  return vpc;
3496 
#undef FLD
3497 
}
3498 
 
3499 
/* bne: bne $label9 */
3500 
 
3501 
static SEM_PC
3502 
SEM_FN_NAME (fr30bf,bne) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3503 
{
3504 
#define FLD(f) abuf->fields.sfmt_brad.f
3505 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3506 
  int UNUSED written = 0;
3507 
  IADDR UNUSED pc = abuf->addr;
3508 
  SEM_BRANCH_INIT
3509 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3510 
 
3511 
if (NOTBI (CPU (h_zbit))) {
3512 
  {
3513 
    USI opval = FLD (i_label9);
3514 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3515 
    written |= (1 << 2);
3516 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3517 
  }
3518 
}
3519 
 
3520 
  abuf->written = written;
3521 
  SEM_BRANCH_FINI (vpc);
3522 
  return vpc;
3523 
#undef FLD
3524 
}
3525 
 
3526 
/* bcd: bc:d $label9 */
3527 
 
3528 
static SEM_PC
3529 
SEM_FN_NAME (fr30bf,bcd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3530 
{
3531 
#define FLD(f) abuf->fields.sfmt_brad.f
3532 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3533 
  int UNUSED written = 0;
3534 
  IADDR UNUSED pc = abuf->addr;
3535 
  SEM_BRANCH_INIT
3536 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3537 
 
3538 
{
3539 
if (CPU (h_cbit)) {
3540 
  {
3541 
    USI opval = FLD (i_label9);
3542 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3543 
    written |= (1 << 2);
3544 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3545 
  }
3546 
}
3547 
}
3548 
 
3549 
  abuf->written = written;
3550 
  SEM_BRANCH_FINI (vpc);
3551 
  return vpc;
3552 
#undef FLD
3553 
}
3554 
 
3555 
/* bc: bc $label9 */
3556 
 
3557 
static SEM_PC
3558 
SEM_FN_NAME (fr30bf,bc) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3559 
{
3560 
#define FLD(f) abuf->fields.sfmt_brad.f
3561 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3562 
  int UNUSED written = 0;
3563 
  IADDR UNUSED pc = abuf->addr;
3564 
  SEM_BRANCH_INIT
3565 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3566 
 
3567 
if (CPU (h_cbit)) {
3568 
  {
3569 
    USI opval = FLD (i_label9);
3570 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3571 
    written |= (1 << 2);
3572 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3573 
  }
3574 
}
3575 
 
3576 
  abuf->written = written;
3577 
  SEM_BRANCH_FINI (vpc);
3578 
  return vpc;
3579 
#undef FLD
3580 
}
3581 
 
3582 
/* bncd: bnc:d $label9 */
3583 
 
3584 
static SEM_PC
3585 
SEM_FN_NAME (fr30bf,bncd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3586 
{
3587 
#define FLD(f) abuf->fields.sfmt_brad.f
3588 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3589 
  int UNUSED written = 0;
3590 
  IADDR UNUSED pc = abuf->addr;
3591 
  SEM_BRANCH_INIT
3592 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3593 
 
3594 
{
3595 
if (NOTBI (CPU (h_cbit))) {
3596 
  {
3597 
    USI opval = FLD (i_label9);
3598 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3599 
    written |= (1 << 2);
3600 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3601 
  }
3602 
}
3603 
}
3604 
 
3605 
  abuf->written = written;
3606 
  SEM_BRANCH_FINI (vpc);
3607 
  return vpc;
3608 
#undef FLD
3609 
}
3610 
 
3611 
/* bnc: bnc $label9 */
3612 
 
3613 
static SEM_PC
3614 
SEM_FN_NAME (fr30bf,bnc) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3615 
{
3616 
#define FLD(f) abuf->fields.sfmt_brad.f
3617 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3618 
  int UNUSED written = 0;
3619 
  IADDR UNUSED pc = abuf->addr;
3620 
  SEM_BRANCH_INIT
3621 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3622 
 
3623 
if (NOTBI (CPU (h_cbit))) {
3624 
  {
3625 
    USI opval = FLD (i_label9);
3626 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3627 
    written |= (1 << 2);
3628 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3629 
  }
3630 
}
3631 
 
3632 
  abuf->written = written;
3633 
  SEM_BRANCH_FINI (vpc);
3634 
  return vpc;
3635 
#undef FLD
3636 
}
3637 
 
3638 
/* bnd: bn:d $label9 */
3639 
 
3640 
static SEM_PC
3641 
SEM_FN_NAME (fr30bf,bnd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3642 
{
3643 
#define FLD(f) abuf->fields.sfmt_brad.f
3644 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3645 
  int UNUSED written = 0;
3646 
  IADDR UNUSED pc = abuf->addr;
3647 
  SEM_BRANCH_INIT
3648 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3649 
 
3650 
{
3651 
if (CPU (h_nbit)) {
3652 
  {
3653 
    USI opval = FLD (i_label9);
3654 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3655 
    written |= (1 << 2);
3656 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3657 
  }
3658 
}
3659 
}
3660 
 
3661 
  abuf->written = written;
3662 
  SEM_BRANCH_FINI (vpc);
3663 
  return vpc;
3664 
#undef FLD
3665 
}
3666 
 
3667 
/* bn: bn $label9 */
3668 
 
3669 
static SEM_PC
3670 
SEM_FN_NAME (fr30bf,bn) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3671 
{
3672 
#define FLD(f) abuf->fields.sfmt_brad.f
3673 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3674 
  int UNUSED written = 0;
3675 
  IADDR UNUSED pc = abuf->addr;
3676 
  SEM_BRANCH_INIT
3677 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3678 
 
3679 
if (CPU (h_nbit)) {
3680 
  {
3681 
    USI opval = FLD (i_label9);
3682 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3683 
    written |= (1 << 2);
3684 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3685 
  }
3686 
}
3687 
 
3688 
  abuf->written = written;
3689 
  SEM_BRANCH_FINI (vpc);
3690 
  return vpc;
3691 
#undef FLD
3692 
}
3693 
 
3694 
/* bpd: bp:d $label9 */
3695 
 
3696 
static SEM_PC
3697 
SEM_FN_NAME (fr30bf,bpd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3698 
{
3699 
#define FLD(f) abuf->fields.sfmt_brad.f
3700 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3701 
  int UNUSED written = 0;
3702 
  IADDR UNUSED pc = abuf->addr;
3703 
  SEM_BRANCH_INIT
3704 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3705 
 
3706 
{
3707 
if (NOTBI (CPU (h_nbit))) {
3708 
  {
3709 
    USI opval = FLD (i_label9);
3710 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3711 
    written |= (1 << 2);
3712 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3713 
  }
3714 
}
3715 
}
3716 
 
3717 
  abuf->written = written;
3718 
  SEM_BRANCH_FINI (vpc);
3719 
  return vpc;
3720 
#undef FLD
3721 
}
3722 
 
3723 
/* bp: bp $label9 */
3724 
 
3725 
static SEM_PC
3726 
SEM_FN_NAME (fr30bf,bp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3727 
{
3728 
#define FLD(f) abuf->fields.sfmt_brad.f
3729 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3730 
  int UNUSED written = 0;
3731 
  IADDR UNUSED pc = abuf->addr;
3732 
  SEM_BRANCH_INIT
3733 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3734 
 
3735 
if (NOTBI (CPU (h_nbit))) {
3736 
  {
3737 
    USI opval = FLD (i_label9);
3738 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3739 
    written |= (1 << 2);
3740 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3741 
  }
3742 
}
3743 
 
3744 
  abuf->written = written;
3745 
  SEM_BRANCH_FINI (vpc);
3746 
  return vpc;
3747 
#undef FLD
3748 
}
3749 
 
3750 
/* bvd: bv:d $label9 */
3751 
 
3752 
static SEM_PC
3753 
SEM_FN_NAME (fr30bf,bvd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3754 
{
3755 
#define FLD(f) abuf->fields.sfmt_brad.f
3756 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3757 
  int UNUSED written = 0;
3758 
  IADDR UNUSED pc = abuf->addr;
3759 
  SEM_BRANCH_INIT
3760 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3761 
 
3762 
{
3763 
if (CPU (h_vbit)) {
3764 
  {
3765 
    USI opval = FLD (i_label9);
3766 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3767 
    written |= (1 << 2);
3768 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3769 
  }
3770 
}
3771 
}
3772 
 
3773 
  abuf->written = written;
3774 
  SEM_BRANCH_FINI (vpc);
3775 
  return vpc;
3776 
#undef FLD
3777 
}
3778 
 
3779 
/* bv: bv $label9 */
3780 
 
3781 
static SEM_PC
3782 
SEM_FN_NAME (fr30bf,bv) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3783 
{
3784 
#define FLD(f) abuf->fields.sfmt_brad.f
3785 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3786 
  int UNUSED written = 0;
3787 
  IADDR UNUSED pc = abuf->addr;
3788 
  SEM_BRANCH_INIT
3789 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3790 
 
3791 
if (CPU (h_vbit)) {
3792 
  {
3793 
    USI opval = FLD (i_label9);
3794 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3795 
    written |= (1 << 2);
3796 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3797 
  }
3798 
}
3799 
 
3800 
  abuf->written = written;
3801 
  SEM_BRANCH_FINI (vpc);
3802 
  return vpc;
3803 
#undef FLD
3804 
}
3805 
 
3806 
/* bnvd: bnv:d $label9 */
3807 
 
3808 
static SEM_PC
3809 
SEM_FN_NAME (fr30bf,bnvd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3810 
{
3811 
#define FLD(f) abuf->fields.sfmt_brad.f
3812 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3813 
  int UNUSED written = 0;
3814 
  IADDR UNUSED pc = abuf->addr;
3815 
  SEM_BRANCH_INIT
3816 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3817 
 
3818 
{
3819 
if (NOTBI (CPU (h_vbit))) {
3820 
  {
3821 
    USI opval = FLD (i_label9);
3822 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3823 
    written |= (1 << 2);
3824 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3825 
  }
3826 
}
3827 
}
3828 
 
3829 
  abuf->written = written;
3830 
  SEM_BRANCH_FINI (vpc);
3831 
  return vpc;
3832 
#undef FLD
3833 
}
3834 
 
3835 
/* bnv: bnv $label9 */
3836 
 
3837 
static SEM_PC
3838 
SEM_FN_NAME (fr30bf,bnv) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3839 
{
3840 
#define FLD(f) abuf->fields.sfmt_brad.f
3841 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3842 
  int UNUSED written = 0;
3843 
  IADDR UNUSED pc = abuf->addr;
3844 
  SEM_BRANCH_INIT
3845 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3846 
 
3847 
if (NOTBI (CPU (h_vbit))) {
3848 
  {
3849 
    USI opval = FLD (i_label9);
3850 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3851 
    written |= (1 << 2);
3852 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3853 
  }
3854 
}
3855 
 
3856 
  abuf->written = written;
3857 
  SEM_BRANCH_FINI (vpc);
3858 
  return vpc;
3859 
#undef FLD
3860 
}
3861 
 
3862 
/* bltd: blt:d $label9 */
3863 
 
3864 
static SEM_PC
3865 
SEM_FN_NAME (fr30bf,bltd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3866 
{
3867 
#define FLD(f) abuf->fields.sfmt_brad.f
3868 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3869 
  int UNUSED written = 0;
3870 
  IADDR UNUSED pc = abuf->addr;
3871 
  SEM_BRANCH_INIT
3872 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3873 
 
3874 
{
3875 
if (XORBI (CPU (h_vbit), CPU (h_nbit))) {
3876 
  {
3877 
    USI opval = FLD (i_label9);
3878 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3879 
    written |= (1 << 3);
3880 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3881 
  }
3882 
}
3883 
}
3884 
 
3885 
  abuf->written = written;
3886 
  SEM_BRANCH_FINI (vpc);
3887 
  return vpc;
3888 
#undef FLD
3889 
}
3890 
 
3891 
/* blt: blt $label9 */
3892 
 
3893 
static SEM_PC
3894 
SEM_FN_NAME (fr30bf,blt) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3895 
{
3896 
#define FLD(f) abuf->fields.sfmt_brad.f
3897 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3898 
  int UNUSED written = 0;
3899 
  IADDR UNUSED pc = abuf->addr;
3900 
  SEM_BRANCH_INIT
3901 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3902 
 
3903 
if (XORBI (CPU (h_vbit), CPU (h_nbit))) {
3904 
  {
3905 
    USI opval = FLD (i_label9);
3906 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3907 
    written |= (1 << 3);
3908 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3909 
  }
3910 
}
3911 
 
3912 
  abuf->written = written;
3913 
  SEM_BRANCH_FINI (vpc);
3914 
  return vpc;
3915 
#undef FLD
3916 
}
3917 
 
3918 
/* bged: bge:d $label9 */
3919 
 
3920 
static SEM_PC
3921 
SEM_FN_NAME (fr30bf,bged) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3922 
{
3923 
#define FLD(f) abuf->fields.sfmt_brad.f
3924 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3925 
  int UNUSED written = 0;
3926 
  IADDR UNUSED pc = abuf->addr;
3927 
  SEM_BRANCH_INIT
3928 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3929 
 
3930 
{
3931 
if (NOTBI (XORBI (CPU (h_vbit), CPU (h_nbit)))) {
3932 
  {
3933 
    USI opval = FLD (i_label9);
3934 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3935 
    written |= (1 << 3);
3936 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3937 
  }
3938 
}
3939 
}
3940 
 
3941 
  abuf->written = written;
3942 
  SEM_BRANCH_FINI (vpc);
3943 
  return vpc;
3944 
#undef FLD
3945 
}
3946 
 
3947 
/* bge: bge $label9 */
3948 
 
3949 
static SEM_PC
3950 
SEM_FN_NAME (fr30bf,bge) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3951 
{
3952 
#define FLD(f) abuf->fields.sfmt_brad.f
3953 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3954 
  int UNUSED written = 0;
3955 
  IADDR UNUSED pc = abuf->addr;
3956 
  SEM_BRANCH_INIT
3957 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3958 
 
3959 
if (NOTBI (XORBI (CPU (h_vbit), CPU (h_nbit)))) {
3960 
  {
3961 
    USI opval = FLD (i_label9);
3962 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3963 
    written |= (1 << 3);
3964 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3965 
  }
3966 
}
3967 
 
3968 
  abuf->written = written;
3969 
  SEM_BRANCH_FINI (vpc);
3970 
  return vpc;
3971 
#undef FLD
3972 
}
3973 
 
3974 
/* bled: ble:d $label9 */
3975 
 
3976 
static SEM_PC
3977 
SEM_FN_NAME (fr30bf,bled) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3978 
{
3979 
#define FLD(f) abuf->fields.sfmt_brad.f
3980 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3981 
  int UNUSED written = 0;
3982 
  IADDR UNUSED pc = abuf->addr;
3983 
  SEM_BRANCH_INIT
3984 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3985 
 
3986 
{
3987 
if (ORBI (XORBI (CPU (h_vbit), CPU (h_nbit)), CPU (h_zbit))) {
3988 
  {
3989 
    USI opval = FLD (i_label9);
3990 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3991 
    written |= (1 << 4);
3992 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3993 
  }
3994 
}
3995 
}
3996 
 
3997 
  abuf->written = written;
3998 
  SEM_BRANCH_FINI (vpc);
3999 
  return vpc;
4000 
#undef FLD
4001 
}
4002 
 
4003 
/* ble: ble $label9 */
4004 
 
4005 
static SEM_PC
4006 
SEM_FN_NAME (fr30bf,ble) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4007 
{
4008 
#define FLD(f) abuf->fields.sfmt_brad.f
4009 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4010 
  int UNUSED written = 0;
4011 
  IADDR UNUSED pc = abuf->addr;
4012 
  SEM_BRANCH_INIT
4013 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4014 
 
4015 
if (ORBI (XORBI (CPU (h_vbit), CPU (h_nbit)), CPU (h_zbit))) {
4016 
  {
4017 
    USI opval = FLD (i_label9);
4018 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
4019 
    written |= (1 << 4);
4020 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
4021 
  }
4022 
}
4023 
 
4024 
  abuf->written = written;
4025 
  SEM_BRANCH_FINI (vpc);
4026 
  return vpc;
4027 
#undef FLD
4028 
}
4029 
 
4030 
/* bgtd: bgt:d $label9 */
4031 
 
4032 
static SEM_PC
4033 
SEM_FN_NAME (fr30bf,bgtd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4034 
{
4035 
#define FLD(f) abuf->fields.sfmt_brad.f
4036 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4037 
  int UNUSED written = 0;
4038 
  IADDR UNUSED pc = abuf->addr;
4039 
  SEM_BRANCH_INIT
4040 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4041 
 
4042 
{
4043 
if (NOTBI (ORBI (XORBI (CPU (h_vbit), CPU (h_nbit)), CPU (h_zbit)))) {
4044 
  {
4045 
    USI opval = FLD (i_label9);
4046 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
4047 
    written |= (1 << 4);
4048 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
4049 
  }
4050 
}
4051 
}
4052 
 
4053 
  abuf->written = written;
4054 
  SEM_BRANCH_FINI (vpc);
4055 
  return vpc;
4056 
#undef FLD
4057 
}
4058 
 
4059 
/* bgt: bgt $label9 */
4060 
 
4061 
static SEM_PC
4062 
SEM_FN_NAME (fr30bf,bgt) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4063 
{
4064 
#define FLD(f) abuf->fields.sfmt_brad.f
4065 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4066 
  int UNUSED written = 0;
4067 
  IADDR UNUSED pc = abuf->addr;
4068 
  SEM_BRANCH_INIT
4069 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4070 
 
4071 
if (NOTBI (ORBI (XORBI (CPU (h_vbit), CPU (h_nbit)), CPU (h_zbit)))) {
4072 
  {
4073 
    USI opval = FLD (i_label9);
4074 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
4075 
    written |= (1 << 4);
4076 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
4077 
  }
4078 
}
4079 
 
4080 
  abuf->written = written;
4081 
  SEM_BRANCH_FINI (vpc);
4082 
  return vpc;
4083 
#undef FLD
4084 
}
4085 
 
4086 
/* blsd: bls:d $label9 */
4087 
 
4088 
static SEM_PC
4089 
SEM_FN_NAME (fr30bf,blsd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4090 
{
4091 
#define FLD(f) abuf->fields.sfmt_brad.f
4092 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4093 
  int UNUSED written = 0;
4094 
  IADDR UNUSED pc = abuf->addr;
4095 
  SEM_BRANCH_INIT
4096 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4097 
 
4098 
{
4099 
if (ORBI (CPU (h_cbit), CPU (h_zbit))) {
4100 
  {
4101 
    USI opval = FLD (i_label9);
4102 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
4103 
    written |= (1 << 3);
4104 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
4105 
  }
4106 
}
4107 
}
4108 
 
4109 
  abuf->written = written;
4110 
  SEM_BRANCH_FINI (vpc);
4111 
  return vpc;
4112 
#undef FLD
4113 
}
4114 
 
4115 
/* bls: bls $label9 */
4116 
 
4117 
static SEM_PC
4118 
SEM_FN_NAME (fr30bf,bls) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4119 
{
4120 
#define FLD(f) abuf->fields.sfmt_brad.f
4121 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4122 
  int UNUSED written = 0;
4123 
  IADDR UNUSED pc = abuf->addr;
4124 
  SEM_BRANCH_INIT
4125 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4126 
 
4127 
if (ORBI (CPU (h_cbit), CPU (h_zbit))) {
4128 
  {
4129 
    USI opval = FLD (i_label9);
4130 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
4131 
    written |= (1 << 3);
4132 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
4133 
  }
4134 
}
4135 
 
4136 
  abuf->written = written;
4137 
  SEM_BRANCH_FINI (vpc);
4138 
  return vpc;
4139 
#undef FLD
4140 
}
4141 
 
4142 
/* bhid: bhi:d $label9 */
4143 
 
4144 
static SEM_PC
4145 
SEM_FN_NAME (fr30bf,bhid) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4146 
{
4147 
#define FLD(f) abuf->fields.sfmt_brad.f
4148 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4149 
  int UNUSED written = 0;
4150 
  IADDR UNUSED pc = abuf->addr;
4151 
  SEM_BRANCH_INIT
4152 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4153 
 
4154 
{
4155 
if (NOTBI (ORBI (CPU (h_cbit), CPU (h_zbit)))) {
4156 
  {
4157 
    USI opval = FLD (i_label9);
4158 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
4159 
    written |= (1 << 3);
4160 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
4161 
  }
4162 
}
4163 
}
4164 
 
4165 
  abuf->written = written;
4166 
  SEM_BRANCH_FINI (vpc);
4167 
  return vpc;
4168 
#undef FLD
4169 
}
4170 
 
4171 
/* bhi: bhi $label9 */
4172 
 
4173 
static SEM_PC
4174 
SEM_FN_NAME (fr30bf,bhi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4175 
{
4176 
#define FLD(f) abuf->fields.sfmt_brad.f
4177 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4178 
  int UNUSED written = 0;
4179 
  IADDR UNUSED pc = abuf->addr;
4180 
  SEM_BRANCH_INIT
4181 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4182 
 
4183 
if (NOTBI (ORBI (CPU (h_cbit), CPU (h_zbit)))) {
4184 
  {
4185 
    USI opval = FLD (i_label9);
4186 
    SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
4187 
    written |= (1 << 3);
4188 
    TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
4189 
  }
4190 
}
4191 
 
4192 
  abuf->written = written;
4193 
  SEM_BRANCH_FINI (vpc);
4194 
  return vpc;
4195 
#undef FLD
4196 
}
4197 
 
4198 
/* dmovr13: dmov $R13,@$dir10 */
4199 
 
4200 
static SEM_PC
4201 
SEM_FN_NAME (fr30bf,dmovr13) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4202 
{
4203 
#define FLD(f) abuf->fields.sfmt_dmovr13pi.f
4204 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4205 
  int UNUSED written = 0;
4206 
  IADDR UNUSED pc = abuf->addr;
4207 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4208 
 
4209 
  {
4210 
    SI opval = CPU (h_gr[((UINT) 13)]);
4211 
    SETMEMSI (current_cpu, pc, FLD (f_dir10), opval);
4212 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4213 
  }
4214 
 
4215 
  return vpc;
4216 
#undef FLD
4217 
}
4218 
 
4219 
/* dmovr13h: dmovh $R13,@$dir9 */
4220 
 
4221 
static SEM_PC
4222 
SEM_FN_NAME (fr30bf,dmovr13h) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4223 
{
4224 
#define FLD(f) abuf->fields.sfmt_dmovr13pih.f
4225 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4226 
  int UNUSED written = 0;
4227 
  IADDR UNUSED pc = abuf->addr;
4228 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4229 
 
4230 
  {
4231 
    HI opval = CPU (h_gr[((UINT) 13)]);
4232 
    SETMEMHI (current_cpu, pc, FLD (f_dir9), opval);
4233 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4234 
  }
4235 
 
4236 
  return vpc;
4237 
#undef FLD
4238 
}
4239 
 
4240 
/* dmovr13b: dmovb $R13,@$dir8 */
4241 
 
4242 
static SEM_PC
4243 
SEM_FN_NAME (fr30bf,dmovr13b) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4244 
{
4245 
#define FLD(f) abuf->fields.sfmt_dmovr13pib.f
4246 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4247 
  int UNUSED written = 0;
4248 
  IADDR UNUSED pc = abuf->addr;
4249 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4250 
 
4251 
  {
4252 
    QI opval = CPU (h_gr[((UINT) 13)]);
4253 
    SETMEMQI (current_cpu, pc, FLD (f_dir8), opval);
4254 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4255 
  }
4256 
 
4257 
  return vpc;
4258 
#undef FLD
4259 
}
4260 
 
4261 
/* dmovr13pi: dmov @$R13+,@$dir10 */
4262 
 
4263 
static SEM_PC
4264 
SEM_FN_NAME (fr30bf,dmovr13pi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4265 
{
4266 
#define FLD(f) abuf->fields.sfmt_dmovr13pi.f
4267 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4268 
  int UNUSED written = 0;
4269 
  IADDR UNUSED pc = abuf->addr;
4270 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4271 
 
4272 
{
4273 
  {
4274 
    SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 13)]));
4275 
    SETMEMSI (current_cpu, pc, FLD (f_dir10), opval);
4276 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4277 
  }
4278 
  {
4279 
    SI opval = ADDSI (CPU (h_gr[((UINT) 13)]), 4);
4280 
    CPU (h_gr[((UINT) 13)]) = opval;
4281 
    TRACE_RESULT (current_cpu, abuf, "gr-13", 'x', opval);
4282 
  }
4283 
}
4284 
 
4285 
  return vpc;
4286 
#undef FLD
4287 
}
4288 
 
4289 
/* dmovr13pih: dmovh @$R13+,@$dir9 */
4290 
 
4291 
static SEM_PC
4292 
SEM_FN_NAME (fr30bf,dmovr13pih) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4293 
{
4294 
#define FLD(f) abuf->fields.sfmt_dmovr13pih.f
4295 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4296 
  int UNUSED written = 0;
4297 
  IADDR UNUSED pc = abuf->addr;
4298 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4299 
 
4300 
{
4301 
  {
4302 
    HI opval = GETMEMHI (current_cpu, pc, CPU (h_gr[((UINT) 13)]));
4303 
    SETMEMHI (current_cpu, pc, FLD (f_dir9), opval);
4304 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4305 
  }
4306 
  {
4307 
    SI opval = ADDSI (CPU (h_gr[((UINT) 13)]), 2);
4308 
    CPU (h_gr[((UINT) 13)]) = opval;
4309 
    TRACE_RESULT (current_cpu, abuf, "gr-13", 'x', opval);
4310 
  }
4311 
}
4312 
 
4313 
  return vpc;
4314 
#undef FLD
4315 
}
4316 
 
4317 
/* dmovr13pib: dmovb @$R13+,@$dir8 */
4318 
 
4319 
static SEM_PC
4320 
SEM_FN_NAME (fr30bf,dmovr13pib) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4321 
{
4322 
#define FLD(f) abuf->fields.sfmt_dmovr13pib.f
4323 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4324 
  int UNUSED written = 0;
4325 
  IADDR UNUSED pc = abuf->addr;
4326 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4327 
 
4328 
{
4329 
  {
4330 
    QI opval = GETMEMQI (current_cpu, pc, CPU (h_gr[((UINT) 13)]));
4331 
    SETMEMQI (current_cpu, pc, FLD (f_dir8), opval);
4332 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4333 
  }
4334 
  {
4335 
    SI opval = ADDSI (CPU (h_gr[((UINT) 13)]), 1);
4336 
    CPU (h_gr[((UINT) 13)]) = opval;
4337 
    TRACE_RESULT (current_cpu, abuf, "gr-13", 'x', opval);
4338 
  }
4339 
}
4340 
 
4341 
  return vpc;
4342 
#undef FLD
4343 
}
4344 
 
4345 
/* dmovr15pi: dmov @$R15+,@$dir10 */
4346 
 
4347 
static SEM_PC
4348 
SEM_FN_NAME (fr30bf,dmovr15pi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4349 
{
4350 
#define FLD(f) abuf->fields.sfmt_dmovr15pi.f
4351 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4352 
  int UNUSED written = 0;
4353 
  IADDR UNUSED pc = abuf->addr;
4354 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4355 
 
4356 
{
4357 
  {
4358 
    SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
4359 
    SETMEMSI (current_cpu, pc, FLD (f_dir10), opval);
4360 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4361 
  }
4362 
  {
4363 
    SI opval = ADDSI (CPU (h_gr[((UINT) 15)]), 4);
4364 
    CPU (h_gr[((UINT) 15)]) = opval;
4365 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
4366 
  }
4367 
}
4368 
 
4369 
  return vpc;
4370 
#undef FLD
4371 
}
4372 
 
4373 
/* dmov2r13: dmov @$dir10,$R13 */
4374 
 
4375 
static SEM_PC
4376 
SEM_FN_NAME (fr30bf,dmov2r13) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4377 
{
4378 
#define FLD(f) abuf->fields.sfmt_dmovr13pi.f
4379 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4380 
  int UNUSED written = 0;
4381 
  IADDR UNUSED pc = abuf->addr;
4382 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4383 
 
4384 
  {
4385 
    SI opval = GETMEMSI (current_cpu, pc, FLD (f_dir10));
4386 
    CPU (h_gr[((UINT) 13)]) = opval;
4387 
    TRACE_RESULT (current_cpu, abuf, "gr-13", 'x', opval);
4388 
  }
4389 
 
4390 
  return vpc;
4391 
#undef FLD
4392 
}
4393 
 
4394 
/* dmov2r13h: dmovh @$dir9,$R13 */
4395 
 
4396 
static SEM_PC
4397 
SEM_FN_NAME (fr30bf,dmov2r13h) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4398 
{
4399 
#define FLD(f) abuf->fields.sfmt_dmovr13pih.f
4400 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4401 
  int UNUSED written = 0;
4402 
  IADDR UNUSED pc = abuf->addr;
4403 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4404 
 
4405 
  {
4406 
    SI opval = GETMEMHI (current_cpu, pc, FLD (f_dir9));
4407 
    CPU (h_gr[((UINT) 13)]) = opval;
4408 
    TRACE_RESULT (current_cpu, abuf, "gr-13", 'x', opval);
4409 
  }
4410 
 
4411 
  return vpc;
4412 
#undef FLD
4413 
}
4414 
 
4415 
/* dmov2r13b: dmovb @$dir8,$R13 */
4416 
 
4417 
static SEM_PC
4418 
SEM_FN_NAME (fr30bf,dmov2r13b) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4419 
{
4420 
#define FLD(f) abuf->fields.sfmt_dmovr13pib.f
4421 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4422 
  int UNUSED written = 0;
4423 
  IADDR UNUSED pc = abuf->addr;
4424 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4425 
 
4426 
  {
4427 
    SI opval = GETMEMQI (current_cpu, pc, FLD (f_dir8));
4428 
    CPU (h_gr[((UINT) 13)]) = opval;
4429 
    TRACE_RESULT (current_cpu, abuf, "gr-13", 'x', opval);
4430 
  }
4431 
 
4432 
  return vpc;
4433 
#undef FLD
4434 
}
4435 
 
4436 
/* dmov2r13pi: dmov @$dir10,@$R13+ */
4437 
 
4438 
static SEM_PC
4439 
SEM_FN_NAME (fr30bf,dmov2r13pi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4440 
{
4441 
#define FLD(f) abuf->fields.sfmt_dmovr13pi.f
4442 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4443 
  int UNUSED written = 0;
4444 
  IADDR UNUSED pc = abuf->addr;
4445 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4446 
 
4447 
{
4448 
  {
4449 
    SI opval = GETMEMSI (current_cpu, pc, FLD (f_dir10));
4450 
    SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 13)]), opval);
4451 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4452 
  }
4453 
  {
4454 
    SI opval = ADDSI (CPU (h_gr[((UINT) 13)]), 4);
4455 
    CPU (h_gr[((UINT) 13)]) = opval;
4456 
    TRACE_RESULT (current_cpu, abuf, "gr-13", 'x', opval);
4457 
  }
4458 
}
4459 
 
4460 
  return vpc;
4461 
#undef FLD
4462 
}
4463 
 
4464 
/* dmov2r13pih: dmovh @$dir9,@$R13+ */
4465 
 
4466 
static SEM_PC
4467 
SEM_FN_NAME (fr30bf,dmov2r13pih) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4468 
{
4469 
#define FLD(f) abuf->fields.sfmt_dmovr13pih.f
4470 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4471 
  int UNUSED written = 0;
4472 
  IADDR UNUSED pc = abuf->addr;
4473 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4474 
 
4475 
{
4476 
  {
4477 
    HI opval = GETMEMHI (current_cpu, pc, FLD (f_dir9));
4478 
    SETMEMHI (current_cpu, pc, CPU (h_gr[((UINT) 13)]), opval);
4479 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4480 
  }
4481 
  {
4482 
    SI opval = ADDSI (CPU (h_gr[((UINT) 13)]), 2);
4483 
    CPU (h_gr[((UINT) 13)]) = opval;
4484 
    TRACE_RESULT (current_cpu, abuf, "gr-13", 'x', opval);
4485 
  }
4486 
}
4487 
 
4488 
  return vpc;
4489 
#undef FLD
4490 
}
4491 
 
4492 
/* dmov2r13pib: dmovb @$dir8,@$R13+ */
4493 
 
4494 
static SEM_PC
4495 
SEM_FN_NAME (fr30bf,dmov2r13pib) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4496 
{
4497 
#define FLD(f) abuf->fields.sfmt_dmovr13pib.f
4498 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4499 
  int UNUSED written = 0;
4500 
  IADDR UNUSED pc = abuf->addr;
4501 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4502 
 
4503 
{
4504 
  {
4505 
    QI opval = GETMEMQI (current_cpu, pc, FLD (f_dir8));
4506 
    SETMEMQI (current_cpu, pc, CPU (h_gr[((UINT) 13)]), opval);
4507 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4508 
  }
4509 
  {
4510 
    SI opval = ADDSI (CPU (h_gr[((UINT) 13)]), 1);
4511 
    CPU (h_gr[((UINT) 13)]) = opval;
4512 
    TRACE_RESULT (current_cpu, abuf, "gr-13", 'x', opval);
4513 
  }
4514 
}
4515 
 
4516 
  return vpc;
4517 
#undef FLD
4518 
}
4519 
 
4520 
/* dmov2r15pd: dmov @$dir10,@-$R15 */
4521 
 
4522 
static SEM_PC
4523 
SEM_FN_NAME (fr30bf,dmov2r15pd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4524 
{
4525 
#define FLD(f) abuf->fields.sfmt_dmovr15pi.f
4526 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4527 
  int UNUSED written = 0;
4528 
  IADDR UNUSED pc = abuf->addr;
4529 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4530 
 
4531 
{
4532 
  {
4533 
    SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
4534 
    CPU (h_gr[((UINT) 15)]) = opval;
4535 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
4536 
  }
4537 
  {
4538 
    SI opval = GETMEMSI (current_cpu, pc, FLD (f_dir10));
4539 
    SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
4540 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4541 
  }
4542 
}
4543 
 
4544 
  return vpc;
4545 
#undef FLD
4546 
}
4547 
 
4548 
/* ldres: ldres @$Ri+,$u4 */
4549 
 
4550 
static SEM_PC
4551 
SEM_FN_NAME (fr30bf,ldres) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4552 
{
4553 
#define FLD(f) abuf->fields.sfmt_add2.f
4554 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4555 
  int UNUSED written = 0;
4556 
  IADDR UNUSED pc = abuf->addr;
4557 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4558 
 
4559 
  {
4560 
    SI opval = ADDSI (* FLD (i_Ri), 4);
4561 
    * FLD (i_Ri) = opval;
4562 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
4563 
  }
4564 
 
4565 
  return vpc;
4566 
#undef FLD
4567 
}
4568 
 
4569 
/* stres: stres $u4,@$Ri+ */
4570 
 
4571 
static SEM_PC
4572 
SEM_FN_NAME (fr30bf,stres) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4573 
{
4574 
#define FLD(f) abuf->fields.sfmt_add2.f
4575 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4576 
  int UNUSED written = 0;
4577 
  IADDR UNUSED pc = abuf->addr;
4578 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4579 
 
4580 
  {
4581 
    SI opval = ADDSI (* FLD (i_Ri), 4);
4582 
    * FLD (i_Ri) = opval;
4583 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
4584 
  }
4585 
 
4586 
  return vpc;
4587 
#undef FLD
4588 
}
4589 
 
4590 
/* copop: copop $u4c,$ccc,$CRj,$CRi */
4591 
 
4592 
static SEM_PC
4593 
SEM_FN_NAME (fr30bf,copop) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4594 
{
4595 
#define FLD(f) abuf->fields.fmt_empty.f
4596 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4597 
  int UNUSED written = 0;
4598 
  IADDR UNUSED pc = abuf->addr;
4599 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4600 
 
4601 
((void) 0); /*nop*/
4602 
 
4603 
  return vpc;
4604 
#undef FLD
4605 
}
4606 
 
4607 
/* copld: copld $u4c,$ccc,$Rjc,$CRi */
4608 
 
4609 
static SEM_PC
4610 
SEM_FN_NAME (fr30bf,copld) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4611 
{
4612 
#define FLD(f) abuf->fields.fmt_empty.f
4613 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4614 
  int UNUSED written = 0;
4615 
  IADDR UNUSED pc = abuf->addr;
4616 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4617 
 
4618 
((void) 0); /*nop*/
4619 
 
4620 
  return vpc;
4621 
#undef FLD
4622 
}
4623 
 
4624 
/* copst: copst $u4c,$ccc,$CRj,$Ric */
4625 
 
4626 
static SEM_PC
4627 
SEM_FN_NAME (fr30bf,copst) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4628 
{
4629 
#define FLD(f) abuf->fields.fmt_empty.f
4630 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4631 
  int UNUSED written = 0;
4632 
  IADDR UNUSED pc = abuf->addr;
4633 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4634 
 
4635 
((void) 0); /*nop*/
4636 
 
4637 
  return vpc;
4638 
#undef FLD
4639 
}
4640 
 
4641 
/* copsv: copsv $u4c,$ccc,$CRj,$Ric */
4642 
 
4643 
static SEM_PC
4644 
SEM_FN_NAME (fr30bf,copsv) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4645 
{
4646 
#define FLD(f) abuf->fields.fmt_empty.f
4647 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4648 
  int UNUSED written = 0;
4649 
  IADDR UNUSED pc = abuf->addr;
4650 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4651 
 
4652 
((void) 0); /*nop*/
4653 
 
4654 
  return vpc;
4655 
#undef FLD
4656 
}
4657 
 
4658 
/* nop: nop */
4659 
 
4660 
static SEM_PC
4661 
SEM_FN_NAME (fr30bf,nop) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4662 
{
4663 
#define FLD(f) abuf->fields.fmt_empty.f
4664 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4665 
  int UNUSED written = 0;
4666 
  IADDR UNUSED pc = abuf->addr;
4667 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4668 
 
4669 
((void) 0); /*nop*/
4670 
 
4671 
  return vpc;
4672 
#undef FLD
4673 
}
4674 
 
4675 
/* andccr: andccr $u8 */
4676 
 
4677 
static SEM_PC
4678 
SEM_FN_NAME (fr30bf,andccr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4679 
{
4680 
#define FLD(f) abuf->fields.sfmt_int.f
4681 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4682 
  int UNUSED written = 0;
4683 
  IADDR UNUSED pc = abuf->addr;
4684 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4685 
 
4686 
  {
4687 
    UQI opval = ANDQI (GET_H_CCR (), FLD (f_u8));
4688 
    SET_H_CCR (opval);
4689 
    TRACE_RESULT (current_cpu, abuf, "ccr", 'x', opval);
4690 
  }
4691 
 
4692 
  return vpc;
4693 
#undef FLD
4694 
}
4695 
 
4696 
/* orccr: orccr $u8 */
4697 
 
4698 
static SEM_PC
4699 
SEM_FN_NAME (fr30bf,orccr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4700 
{
4701 
#define FLD(f) abuf->fields.sfmt_int.f
4702 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4703 
  int UNUSED written = 0;
4704 
  IADDR UNUSED pc = abuf->addr;
4705 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4706 
 
4707 
  {
4708 
    UQI opval = ORQI (GET_H_CCR (), FLD (f_u8));
4709 
    SET_H_CCR (opval);
4710 
    TRACE_RESULT (current_cpu, abuf, "ccr", 'x', opval);
4711 
  }
4712 
 
4713 
  return vpc;
4714 
#undef FLD
4715 
}
4716 
 
4717 
/* stilm: stilm $u8 */
4718 
 
4719 
static SEM_PC
4720 
SEM_FN_NAME (fr30bf,stilm) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4721 
{
4722 
#define FLD(f) abuf->fields.sfmt_int.f
4723 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4724 
  int UNUSED written = 0;
4725 
  IADDR UNUSED pc = abuf->addr;
4726 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4727 
 
4728 
  {
4729 
    UQI opval = ANDSI (FLD (f_u8), 31);
4730 
    SET_H_ILM (opval);
4731 
    TRACE_RESULT (current_cpu, abuf, "ilm", 'x', opval);
4732 
  }
4733 
 
4734 
  return vpc;
4735 
#undef FLD
4736 
}
4737 
 
4738 
/* addsp: addsp $s10 */
4739 
 
4740 
static SEM_PC
4741 
SEM_FN_NAME (fr30bf,addsp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4742 
{
4743 
#define FLD(f) abuf->fields.sfmt_addsp.f
4744 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4745 
  int UNUSED written = 0;
4746 
  IADDR UNUSED pc = abuf->addr;
4747 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4748 
 
4749 
  {
4750 
    SI opval = ADDSI (CPU (h_gr[((UINT) 15)]), FLD (f_s10));
4751 
    CPU (h_gr[((UINT) 15)]) = opval;
4752 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
4753 
  }
4754 
 
4755 
  return vpc;
4756 
#undef FLD
4757 
}
4758 
 
4759 
/* extsb: extsb $Ri */
4760 
 
4761 
static SEM_PC
4762 
SEM_FN_NAME (fr30bf,extsb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4763 
{
4764 
#define FLD(f) abuf->fields.sfmt_add2.f
4765 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4766 
  int UNUSED written = 0;
4767 
  IADDR UNUSED pc = abuf->addr;
4768 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4769 
 
4770 
  {
4771 
    SI opval = EXTQISI (ANDQI (* FLD (i_Ri), 255));
4772 
    * FLD (i_Ri) = opval;
4773 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
4774 
  }
4775 
 
4776 
  return vpc;
4777 
#undef FLD
4778 
}
4779 
 
4780 
/* extub: extub $Ri */
4781 
 
4782 
static SEM_PC
4783 
SEM_FN_NAME (fr30bf,extub) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4784 
{
4785 
#define FLD(f) abuf->fields.sfmt_add2.f
4786 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4787 
  int UNUSED written = 0;
4788 
  IADDR UNUSED pc = abuf->addr;
4789 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4790 
 
4791 
  {
4792 
    SI opval = ZEXTQISI (ANDQI (* FLD (i_Ri), 255));
4793 
    * FLD (i_Ri) = opval;
4794 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
4795 
  }
4796 
 
4797 
  return vpc;
4798 
#undef FLD
4799 
}
4800 
 
4801 
/* extsh: extsh $Ri */
4802 
 
4803 
static SEM_PC
4804 
SEM_FN_NAME (fr30bf,extsh) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4805 
{
4806 
#define FLD(f) abuf->fields.sfmt_add2.f
4807 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4808 
  int UNUSED written = 0;
4809 
  IADDR UNUSED pc = abuf->addr;
4810 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4811 
 
4812 
  {
4813 
    SI opval = EXTHISI (ANDHI (* FLD (i_Ri), 65535));
4814 
    * FLD (i_Ri) = opval;
4815 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
4816 
  }
4817 
 
4818 
  return vpc;
4819 
#undef FLD
4820 
}
4821 
 
4822 
/* extuh: extuh $Ri */
4823 
 
4824 
static SEM_PC
4825 
SEM_FN_NAME (fr30bf,extuh) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4826 
{
4827 
#define FLD(f) abuf->fields.sfmt_add2.f
4828 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4829 
  int UNUSED written = 0;
4830 
  IADDR UNUSED pc = abuf->addr;
4831 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4832 
 
4833 
  {
4834 
    SI opval = ZEXTHISI (ANDHI (* FLD (i_Ri), 65535));
4835 
    * FLD (i_Ri) = opval;
4836 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
4837 
  }
4838 
 
4839 
  return vpc;
4840 
#undef FLD
4841 
}
4842 
 
4843 
/* ldm0: ldm0 ($reglist_low_ld) */
4844 
 
4845 
static SEM_PC
4846 
SEM_FN_NAME (fr30bf,ldm0) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4847 
{
4848 
#define FLD(f) abuf->fields.sfmt_ldm0.f
4849 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4850 
  int UNUSED written = 0;
4851 
  IADDR UNUSED pc = abuf->addr;
4852 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4853 
 
4854 
{
4855 
if (ANDSI (FLD (f_reglist_low_ld), 1)) {
4856 
{
4857 
  {
4858 
    SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
4859 
    CPU (h_gr[((UINT) 0)]) = opval;
4860 
    written |= (1 << 3);
4861 
    TRACE_RESULT (current_cpu, abuf, "gr-0", 'x', opval);
4862 
  }
4863 
  {
4864 
    SI opval = ADDSI (CPU (h_gr[((UINT) 15)]), 4);
4865 
    CPU (h_gr[((UINT) 15)]) = opval;
4866 
    written |= (1 << 5);
4867 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
4868 
  }
4869 
}
4870 
}
4871 
if (ANDSI (FLD (f_reglist_low_ld), 2)) {
4872 
{
4873 
  {
4874 
    SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
4875 
    CPU (h_gr[((UINT) 1)]) = opval;
4876 
    written |= (1 << 4);
4877 
    TRACE_RESULT (current_cpu, abuf, "gr-1", 'x', opval);
4878 
  }
4879 
  {
4880 
    SI opval = ADDSI (CPU (h_gr[((UINT) 15)]), 4);
4881 
    CPU (h_gr[((UINT) 15)]) = opval;
4882 
    written |= (1 << 5);
4883 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
4884 
  }
4885 
}
4886 
}
4887 
if (ANDSI (FLD (f_reglist_low_ld), 4)) {
4888 
{
4889 
  {
4890 
    SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
4891 
    CPU (h_gr[((UINT) 2)]) = opval;
4892 
    written |= (1 << 6);
4893 
    TRACE_RESULT (current_cpu, abuf, "gr-2", 'x', opval);
4894 
  }
4895 
  {
4896 
    SI opval = ADDSI (CPU (h_gr[((UINT) 15)]), 4);
4897 
    CPU (h_gr[((UINT) 15)]) = opval;
4898 
    written |= (1 << 5);
4899 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
4900 
  }
4901 
}
4902 
}
4903 
if (ANDSI (FLD (f_reglist_low_ld), 8)) {
4904 
{
4905 
  {
4906 
    SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
4907 
    CPU (h_gr[((UINT) 3)]) = opval;
4908 
    written |= (1 << 7);
4909 
    TRACE_RESULT (current_cpu, abuf, "gr-3", 'x', opval);
4910 
  }
4911 
  {
4912 
    SI opval = ADDSI (CPU (h_gr[((UINT) 15)]), 4);
4913 
    CPU (h_gr[((UINT) 15)]) = opval;
4914 
    written |= (1 << 5);
4915 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
4916 
  }
4917 
}
4918 
}
4919 
if (ANDSI (FLD (f_reglist_low_ld), 16)) {
4920 
{
4921 
  {
4922 
    SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
4923 
    CPU (h_gr[((UINT) 4)]) = opval;
4924 
    written |= (1 << 8);
4925 
    TRACE_RESULT (current_cpu, abuf, "gr-4", 'x', opval);
4926 
  }
4927 
  {
4928 
    SI opval = ADDSI (CPU (h_gr[((UINT) 15)]), 4);
4929 
    CPU (h_gr[((UINT) 15)]) = opval;
4930 
    written |= (1 << 5);
4931 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
4932 
  }
4933 
}
4934 
}
4935 
if (ANDSI (FLD (f_reglist_low_ld), 32)) {
4936 
{
4937 
  {
4938 
    SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
4939 
    CPU (h_gr[((UINT) 5)]) = opval;
4940 
    written |= (1 << 9);
4941 
    TRACE_RESULT (current_cpu, abuf, "gr-5", 'x', opval);
4942 
  }
4943 
  {
4944 
    SI opval = ADDSI (CPU (h_gr[((UINT) 15)]), 4);
4945 
    CPU (h_gr[((UINT) 15)]) = opval;
4946 
    written |= (1 << 5);
4947 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
4948 
  }
4949 
}
4950 
}
4951 
if (ANDSI (FLD (f_reglist_low_ld), 64)) {
4952 
{
4953 
  {
4954 
    SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
4955 
    CPU (h_gr[((UINT) 6)]) = opval;
4956 
    written |= (1 << 10);
4957 
    TRACE_RESULT (current_cpu, abuf, "gr-6", 'x', opval);
4958 
  }
4959 
  {
4960 
    SI opval = ADDSI (CPU (h_gr[((UINT) 15)]), 4);
4961 
    CPU (h_gr[((UINT) 15)]) = opval;
4962 
    written |= (1 << 5);
4963 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
4964 
  }
4965 
}
4966 
}
4967 
if (ANDSI (FLD (f_reglist_low_ld), 128)) {
4968 
{
4969 
  {
4970 
    SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
4971 
    CPU (h_gr[((UINT) 7)]) = opval;
4972 
    written |= (1 << 11);
4973 
    TRACE_RESULT (current_cpu, abuf, "gr-7", 'x', opval);
4974 
  }
4975 
  {
4976 
    SI opval = ADDSI (CPU (h_gr[((UINT) 15)]), 4);
4977 
    CPU (h_gr[((UINT) 15)]) = opval;
4978 
    written |= (1 << 5);
4979 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
4980 
  }
4981 
}
4982 
}
4983 
}
4984 
 
4985 
  abuf->written = written;
4986 
  return vpc;
4987 
#undef FLD
4988 
}
4989 
 
4990 
/* ldm1: ldm1 ($reglist_hi_ld) */
4991 
 
4992 
static SEM_PC
4993 
SEM_FN_NAME (fr30bf,ldm1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4994 
{
4995 
#define FLD(f) abuf->fields.sfmt_ldm1.f
4996 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4997 
  int UNUSED written = 0;
4998 
  IADDR UNUSED pc = abuf->addr;
4999 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5000 
 
5001 
{
5002 
if (ANDSI (FLD (f_reglist_hi_ld), 1)) {
5003 
{
5004 
  {
5005 
    SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
5006 
    CPU (h_gr[((UINT) 8)]) = opval;
5007 
    written |= (1 << 9);
5008 
    TRACE_RESULT (current_cpu, abuf, "gr-8", 'x', opval);
5009 
  }
5010 
  {
5011 
    SI opval = ADDSI (CPU (h_gr[((UINT) 15)]), 4);
5012 
    CPU (h_gr[((UINT) 15)]) = opval;
5013 
    written |= (1 << 8);
5014 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5015 
  }
5016 
}
5017 
}
5018 
if (ANDSI (FLD (f_reglist_hi_ld), 2)) {
5019 
{
5020 
  {
5021 
    SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
5022 
    CPU (h_gr[((UINT) 9)]) = opval;
5023 
    written |= (1 << 10);
5024 
    TRACE_RESULT (current_cpu, abuf, "gr-9", 'x', opval);
5025 
  }
5026 
  {
5027 
    SI opval = ADDSI (CPU (h_gr[((UINT) 15)]), 4);
5028 
    CPU (h_gr[((UINT) 15)]) = opval;
5029 
    written |= (1 << 8);
5030 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5031 
  }
5032 
}
5033 
}
5034 
if (ANDSI (FLD (f_reglist_hi_ld), 4)) {
5035 
{
5036 
  {
5037 
    SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
5038 
    CPU (h_gr[((UINT) 10)]) = opval;
5039 
    written |= (1 << 3);
5040 
    TRACE_RESULT (current_cpu, abuf, "gr-10", 'x', opval);
5041 
  }
5042 
  {
5043 
    SI opval = ADDSI (CPU (h_gr[((UINT) 15)]), 4);
5044 
    CPU (h_gr[((UINT) 15)]) = opval;
5045 
    written |= (1 << 8);
5046 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5047 
  }
5048 
}
5049 
}
5050 
if (ANDSI (FLD (f_reglist_hi_ld), 8)) {
5051 
{
5052 
  {
5053 
    SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
5054 
    CPU (h_gr[((UINT) 11)]) = opval;
5055 
    written |= (1 << 4);
5056 
    TRACE_RESULT (current_cpu, abuf, "gr-11", 'x', opval);
5057 
  }
5058 
  {
5059 
    SI opval = ADDSI (CPU (h_gr[((UINT) 15)]), 4);
5060 
    CPU (h_gr[((UINT) 15)]) = opval;
5061 
    written |= (1 << 8);
5062 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5063 
  }
5064 
}
5065 
}
5066 
if (ANDSI (FLD (f_reglist_hi_ld), 16)) {
5067 
{
5068 
  {
5069 
    SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
5070 
    CPU (h_gr[((UINT) 12)]) = opval;
5071 
    written |= (1 << 5);
5072 
    TRACE_RESULT (current_cpu, abuf, "gr-12", 'x', opval);
5073 
  }
5074 
  {
5075 
    SI opval = ADDSI (CPU (h_gr[((UINT) 15)]), 4);
5076 
    CPU (h_gr[((UINT) 15)]) = opval;
5077 
    written |= (1 << 8);
5078 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5079 
  }
5080 
}
5081 
}
5082 
if (ANDSI (FLD (f_reglist_hi_ld), 32)) {
5083 
{
5084 
  {
5085 
    SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
5086 
    CPU (h_gr[((UINT) 13)]) = opval;
5087 
    written |= (1 << 6);
5088 
    TRACE_RESULT (current_cpu, abuf, "gr-13", 'x', opval);
5089 
  }
5090 
  {
5091 
    SI opval = ADDSI (CPU (h_gr[((UINT) 15)]), 4);
5092 
    CPU (h_gr[((UINT) 15)]) = opval;
5093 
    written |= (1 << 8);
5094 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5095 
  }
5096 
}
5097 
}
5098 
if (ANDSI (FLD (f_reglist_hi_ld), 64)) {
5099 
{
5100 
  {
5101 
    SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
5102 
    CPU (h_gr[((UINT) 14)]) = opval;
5103 
    written |= (1 << 7);
5104 
    TRACE_RESULT (current_cpu, abuf, "gr-14", 'x', opval);
5105 
  }
5106 
  {
5107 
    SI opval = ADDSI (CPU (h_gr[((UINT) 15)]), 4);
5108 
    CPU (h_gr[((UINT) 15)]) = opval;
5109 
    written |= (1 << 8);
5110 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5111 
  }
5112 
}
5113 
}
5114 
if (ANDSI (FLD (f_reglist_hi_ld), 128)) {
5115 
  {
5116 
    SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
5117 
    CPU (h_gr[((UINT) 15)]) = opval;
5118 
    written |= (1 << 8);
5119 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5120 
  }
5121 
}
5122 
}
5123 
 
5124 
  abuf->written = written;
5125 
  return vpc;
5126 
#undef FLD
5127 
}
5128 
 
5129 
/* stm0: stm0 ($reglist_low_st) */
5130 
 
5131 
static SEM_PC
5132 
SEM_FN_NAME (fr30bf,stm0) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5133 
{
5134 
#define FLD(f) abuf->fields.sfmt_stm0.f
5135 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5136 
  int UNUSED written = 0;
5137 
  IADDR UNUSED pc = abuf->addr;
5138 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5139 
 
5140 
{
5141 
if (ANDSI (FLD (f_reglist_low_st), 1)) {
5142 
{
5143 
  {
5144 
    SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
5145 
    CPU (h_gr[((UINT) 15)]) = opval;
5146 
    written |= (1 << 10);
5147 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5148 
  }
5149 
  {
5150 
    SI opval = CPU (h_gr[((UINT) 7)]);
5151 
    SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
5152 
    written |= (1 << 11);
5153 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5154 
  }
5155 
}
5156 
}
5157 
if (ANDSI (FLD (f_reglist_low_st), 2)) {
5158 
{
5159 
  {
5160 
    SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
5161 
    CPU (h_gr[((UINT) 15)]) = opval;
5162 
    written |= (1 << 10);
5163 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5164 
  }
5165 
  {
5166 
    SI opval = CPU (h_gr[((UINT) 6)]);
5167 
    SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
5168 
    written |= (1 << 11);
5169 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5170 
  }
5171 
}
5172 
}
5173 
if (ANDSI (FLD (f_reglist_low_st), 4)) {
5174 
{
5175 
  {
5176 
    SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
5177 
    CPU (h_gr[((UINT) 15)]) = opval;
5178 
    written |= (1 << 10);
5179 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5180 
  }
5181 
  {
5182 
    SI opval = CPU (h_gr[((UINT) 5)]);
5183 
    SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
5184 
    written |= (1 << 11);
5185 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5186 
  }
5187 
}
5188 
}
5189 
if (ANDSI (FLD (f_reglist_low_st), 8)) {
5190 
{
5191 
  {
5192 
    SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
5193 
    CPU (h_gr[((UINT) 15)]) = opval;
5194 
    written |= (1 << 10);
5195 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5196 
  }
5197 
  {
5198 
    SI opval = CPU (h_gr[((UINT) 4)]);
5199 
    SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
5200 
    written |= (1 << 11);
5201 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5202 
  }
5203 
}
5204 
}
5205 
if (ANDSI (FLD (f_reglist_low_st), 16)) {
5206 
{
5207 
  {
5208 
    SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
5209 
    CPU (h_gr[((UINT) 15)]) = opval;
5210 
    written |= (1 << 10);
5211 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5212 
  }
5213 
  {
5214 
    SI opval = CPU (h_gr[((UINT) 3)]);
5215 
    SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
5216 
    written |= (1 << 11);
5217 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5218 
  }
5219 
}
5220 
}
5221 
if (ANDSI (FLD (f_reglist_low_st), 32)) {
5222 
{
5223 
  {
5224 
    SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
5225 
    CPU (h_gr[((UINT) 15)]) = opval;
5226 
    written |= (1 << 10);
5227 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5228 
  }
5229 
  {
5230 
    SI opval = CPU (h_gr[((UINT) 2)]);
5231 
    SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
5232 
    written |= (1 << 11);
5233 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5234 
  }
5235 
}
5236 
}
5237 
if (ANDSI (FLD (f_reglist_low_st), 64)) {
5238 
{
5239 
  {
5240 
    SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
5241 
    CPU (h_gr[((UINT) 15)]) = opval;
5242 
    written |= (1 << 10);
5243 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5244 
  }
5245 
  {
5246 
    SI opval = CPU (h_gr[((UINT) 1)]);
5247 
    SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
5248 
    written |= (1 << 11);
5249 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5250 
  }
5251 
}
5252 
}
5253 
if (ANDSI (FLD (f_reglist_low_st), 128)) {
5254 
{
5255 
  {
5256 
    SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
5257 
    CPU (h_gr[((UINT) 15)]) = opval;
5258 
    written |= (1 << 10);
5259 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5260 
  }
5261 
  {
5262 
    SI opval = CPU (h_gr[((UINT) 0)]);
5263 
    SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
5264 
    written |= (1 << 11);
5265 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5266 
  }
5267 
}
5268 
}
5269 
}
5270 
 
5271 
  abuf->written = written;
5272 
  return vpc;
5273 
#undef FLD
5274 
}
5275 
 
5276 
/* stm1: stm1 ($reglist_hi_st) */
5277 
 
5278 
static SEM_PC
5279 
SEM_FN_NAME (fr30bf,stm1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5280 
{
5281 
#define FLD(f) abuf->fields.sfmt_stm1.f
5282 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5283 
  int UNUSED written = 0;
5284 
  IADDR UNUSED pc = abuf->addr;
5285 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5286 
 
5287 
{
5288 
if (ANDSI (FLD (f_reglist_hi_st), 1)) {
5289 
{
5290 
  SI tmp_save_r15;
5291 
  tmp_save_r15 = CPU (h_gr[((UINT) 15)]);
5292 
  {
5293 
    SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
5294 
    CPU (h_gr[((UINT) 15)]) = opval;
5295 
    written |= (1 << 9);
5296 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5297 
  }
5298 
  {
5299 
    SI opval = tmp_save_r15;
5300 
    SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
5301 
    written |= (1 << 10);
5302 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5303 
  }
5304 
}
5305 
}
5306 
if (ANDSI (FLD (f_reglist_hi_st), 2)) {
5307 
{
5308 
  {
5309 
    SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
5310 
    CPU (h_gr[((UINT) 15)]) = opval;
5311 
    written |= (1 << 9);
5312 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5313 
  }
5314 
  {
5315 
    SI opval = CPU (h_gr[((UINT) 14)]);
5316 
    SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
5317 
    written |= (1 << 10);
5318 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5319 
  }
5320 
}
5321 
}
5322 
if (ANDSI (FLD (f_reglist_hi_st), 4)) {
5323 
{
5324 
  {
5325 
    SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
5326 
    CPU (h_gr[((UINT) 15)]) = opval;
5327 
    written |= (1 << 9);
5328 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5329 
  }
5330 
  {
5331 
    SI opval = CPU (h_gr[((UINT) 13)]);
5332 
    SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
5333 
    written |= (1 << 10);
5334 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5335 
  }
5336 
}
5337 
}
5338 
if (ANDSI (FLD (f_reglist_hi_st), 8)) {
5339 
{
5340 
  {
5341 
    SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
5342 
    CPU (h_gr[((UINT) 15)]) = opval;
5343 
    written |= (1 << 9);
5344 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5345 
  }
5346 
  {
5347 
    SI opval = CPU (h_gr[((UINT) 12)]);
5348 
    SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
5349 
    written |= (1 << 10);
5350 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5351 
  }
5352 
}
5353 
}
5354 
if (ANDSI (FLD (f_reglist_hi_st), 16)) {
5355 
{
5356 
  {
5357 
    SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
5358 
    CPU (h_gr[((UINT) 15)]) = opval;
5359 
    written |= (1 << 9);
5360 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5361 
  }
5362 
  {
5363 
    SI opval = CPU (h_gr[((UINT) 11)]);
5364 
    SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
5365 
    written |= (1 << 10);
5366 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5367 
  }
5368 
}
5369 
}
5370 
if (ANDSI (FLD (f_reglist_hi_st), 32)) {
5371 
{
5372 
  {
5373 
    SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
5374 
    CPU (h_gr[((UINT) 15)]) = opval;
5375 
    written |= (1 << 9);
5376 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5377 
  }
5378 
  {
5379 
    SI opval = CPU (h_gr[((UINT) 10)]);
5380 
    SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
5381 
    written |= (1 << 10);
5382 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5383 
  }
5384 
}
5385 
}
5386 
if (ANDSI (FLD (f_reglist_hi_st), 64)) {
5387 
{
5388 
  {
5389 
    SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
5390 
    CPU (h_gr[((UINT) 15)]) = opval;
5391 
    written |= (1 << 9);
5392 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5393 
  }
5394 
  {
5395 
    SI opval = CPU (h_gr[((UINT) 9)]);
5396 
    SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
5397 
    written |= (1 << 10);
5398 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5399 
  }
5400 
}
5401 
}
5402 
if (ANDSI (FLD (f_reglist_hi_st), 128)) {
5403 
{
5404 
  {
5405 
    SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
5406 
    CPU (h_gr[((UINT) 15)]) = opval;
5407 
    written |= (1 << 9);
5408 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5409 
  }
5410 
  {
5411 
    SI opval = CPU (h_gr[((UINT) 8)]);
5412 
    SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
5413 
    written |= (1 << 10);
5414 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5415 
  }
5416 
}
5417 
}
5418 
}
5419 
 
5420 
  abuf->written = written;
5421 
  return vpc;
5422 
#undef FLD
5423 
}
5424 
 
5425 
/* enter: enter $u10 */
5426 
 
5427 
static SEM_PC
5428 
SEM_FN_NAME (fr30bf,enter) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5429 
{
5430 
#define FLD(f) abuf->fields.sfmt_enter.f
5431 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5432 
  int UNUSED written = 0;
5433 
  IADDR UNUSED pc = abuf->addr;
5434 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5435 
 
5436 
{
5437 
  SI tmp_tmp;
5438 
  tmp_tmp = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
5439 
  {
5440 
    SI opval = CPU (h_gr[((UINT) 14)]);
5441 
    SETMEMSI (current_cpu, pc, tmp_tmp, opval);
5442 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5443 
  }
5444 
  {
5445 
    SI opval = tmp_tmp;
5446 
    CPU (h_gr[((UINT) 14)]) = opval;
5447 
    TRACE_RESULT (current_cpu, abuf, "gr-14", 'x', opval);
5448 
  }
5449 
  {
5450 
    SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), FLD (f_u10));
5451 
    CPU (h_gr[((UINT) 15)]) = opval;
5452 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5453 
  }
5454 
}
5455 
 
5456 
  return vpc;
5457 
#undef FLD
5458 
}
5459 
 
5460 
/* leave: leave */
5461 
 
5462 
static SEM_PC
5463 
SEM_FN_NAME (fr30bf,leave) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5464 
{
5465 
#define FLD(f) abuf->fields.sfmt_enter.f
5466 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5467 
  int UNUSED written = 0;
5468 
  IADDR UNUSED pc = abuf->addr;
5469 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5470 
 
5471 
{
5472 
  {
5473 
    SI opval = ADDSI (CPU (h_gr[((UINT) 14)]), 4);
5474 
    CPU (h_gr[((UINT) 15)]) = opval;
5475 
    TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
5476 
  }
5477 
  {
5478 
    SI opval = GETMEMSI (current_cpu, pc, SUBSI (CPU (h_gr[((UINT) 15)]), 4));
5479 
    CPU (h_gr[((UINT) 14)]) = opval;
5480 
    TRACE_RESULT (current_cpu, abuf, "gr-14", 'x', opval);
5481 
  }
5482 
}
5483 
 
5484 
  return vpc;
5485 
#undef FLD
5486 
}
5487 
 
5488 
/* xchb: xchb @$Rj,$Ri */
5489 
 
5490 
static SEM_PC
5491 
SEM_FN_NAME (fr30bf,xchb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5492 
{
5493 
#define FLD(f) abuf->fields.sfmt_add.f
5494 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5495 
  int UNUSED written = 0;
5496 
  IADDR UNUSED pc = abuf->addr;
5497 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5498 
 
5499 
{
5500 
  SI tmp_tmp;
5501 
  tmp_tmp = * FLD (i_Ri);
5502 
  {
5503 
    SI opval = GETMEMUQI (current_cpu, pc, * FLD (i_Rj));
5504 
    * FLD (i_Ri) = opval;
5505 
    TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
5506 
  }
5507 
  {
5508 
    UQI opval = tmp_tmp;
5509 
    SETMEMUQI (current_cpu, pc, * FLD (i_Rj), opval);
5510 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5511 
  }
5512 
}
5513 
 
5514 
  return vpc;
5515 
#undef FLD
5516 
}
5517 
 
5518 
/* Table of all semantic fns.  */
5519 
 
5520 
static const struct sem_fn_desc sem_fns[] = {
5521 
  { FR30BF_INSN_X_INVALID, SEM_FN_NAME (fr30bf,x_invalid) },
5522 
  { FR30BF_INSN_X_AFTER, SEM_FN_NAME (fr30bf,x_after) },
5523 
  { FR30BF_INSN_X_BEFORE, SEM_FN_NAME (fr30bf,x_before) },
5524 
  { FR30BF_INSN_X_CTI_CHAIN, SEM_FN_NAME (fr30bf,x_cti_chain) },
5525 
  { FR30BF_INSN_X_CHAIN, SEM_FN_NAME (fr30bf,x_chain) },
5526 
  { FR30BF_INSN_X_BEGIN, SEM_FN_NAME (fr30bf,x_begin) },
5527 
  { FR30BF_INSN_ADD, SEM_FN_NAME (fr30bf,add) },
5528 
  { FR30BF_INSN_ADDI, SEM_FN_NAME (fr30bf,addi) },
5529 
  { FR30BF_INSN_ADD2, SEM_FN_NAME (fr30bf,add2) },
5530 
  { FR30BF_INSN_ADDC, SEM_FN_NAME (fr30bf,addc) },
5531 
  { FR30BF_INSN_ADDN, SEM_FN_NAME (fr30bf,addn) },
5532 
  { FR30BF_INSN_ADDNI, SEM_FN_NAME (fr30bf,addni) },
5533 
  { FR30BF_INSN_ADDN2, SEM_FN_NAME (fr30bf,addn2) },
5534 
  { FR30BF_INSN_SUB, SEM_FN_NAME (fr30bf,sub) },
5535 
  { FR30BF_INSN_SUBC, SEM_FN_NAME (fr30bf,subc) },
5536 
  { FR30BF_INSN_SUBN, SEM_FN_NAME (fr30bf,subn) },
5537 
  { FR30BF_INSN_CMP, SEM_FN_NAME (fr30bf,cmp) },
5538 
  { FR30BF_INSN_CMPI, SEM_FN_NAME (fr30bf,cmpi) },
5539 
  { FR30BF_INSN_CMP2, SEM_FN_NAME (fr30bf,cmp2) },
5540 
  { FR30BF_INSN_AND, SEM_FN_NAME (fr30bf,and) },
5541 
  { FR30BF_INSN_OR, SEM_FN_NAME (fr30bf,or) },
5542 
  { FR30BF_INSN_EOR, SEM_FN_NAME (fr30bf,eor) },
5543 
  { FR30BF_INSN_ANDM, SEM_FN_NAME (fr30bf,andm) },
5544 
  { FR30BF_INSN_ANDH, SEM_FN_NAME (fr30bf,andh) },
5545 
  { FR30BF_INSN_ANDB, SEM_FN_NAME (fr30bf,andb) },
5546 
  { FR30BF_INSN_ORM, SEM_FN_NAME (fr30bf,orm) },
5547 
  { FR30BF_INSN_ORH, SEM_FN_NAME (fr30bf,orh) },
5548 
  { FR30BF_INSN_ORB, SEM_FN_NAME (fr30bf,orb) },
5549 
  { FR30BF_INSN_EORM, SEM_FN_NAME (fr30bf,eorm) },
5550 
  { FR30BF_INSN_EORH, SEM_FN_NAME (fr30bf,eorh) },
5551 
  { FR30BF_INSN_EORB, SEM_FN_NAME (fr30bf,eorb) },
5552 
  { FR30BF_INSN_BANDL, SEM_FN_NAME (fr30bf,bandl) },
5553 
  { FR30BF_INSN_BORL, SEM_FN_NAME (fr30bf,borl) },
5554 
  { FR30BF_INSN_BEORL, SEM_FN_NAME (fr30bf,beorl) },
5555 
  { FR30BF_INSN_BANDH, SEM_FN_NAME (fr30bf,bandh) },
5556 
  { FR30BF_INSN_BORH, SEM_FN_NAME (fr30bf,borh) },
5557 
  { FR30BF_INSN_BEORH, SEM_FN_NAME (fr30bf,beorh) },
5558 
  { FR30BF_INSN_BTSTL, SEM_FN_NAME (fr30bf,btstl) },
5559 
  { FR30BF_INSN_BTSTH, SEM_FN_NAME (fr30bf,btsth) },
5560 
  { FR30BF_INSN_MUL, SEM_FN_NAME (fr30bf,mul) },
5561 
  { FR30BF_INSN_MULU, SEM_FN_NAME (fr30bf,mulu) },
5562 
  { FR30BF_INSN_MULH, SEM_FN_NAME (fr30bf,mulh) },
5563 
  { FR30BF_INSN_MULUH, SEM_FN_NAME (fr30bf,muluh) },
5564 
  { FR30BF_INSN_DIV0S, SEM_FN_NAME (fr30bf,div0s) },
5565 
  { FR30BF_INSN_DIV0U, SEM_FN_NAME (fr30bf,div0u) },
5566 
  { FR30BF_INSN_DIV1, SEM_FN_NAME (fr30bf,div1) },
5567 
  { FR30BF_INSN_DIV2, SEM_FN_NAME (fr30bf,div2) },
5568 
  { FR30BF_INSN_DIV3, SEM_FN_NAME (fr30bf,div3) },
5569 
  { FR30BF_INSN_DIV4S, SEM_FN_NAME (fr30bf,div4s) },
5570 
  { FR30BF_INSN_LSL, SEM_FN_NAME (fr30bf,lsl) },
5571 
  { FR30BF_INSN_LSLI, SEM_FN_NAME (fr30bf,lsli) },
5572 
  { FR30BF_INSN_LSL2, SEM_FN_NAME (fr30bf,lsl2) },
5573 
  { FR30BF_INSN_LSR, SEM_FN_NAME (fr30bf,lsr) },
5574 
  { FR30BF_INSN_LSRI, SEM_FN_NAME (fr30bf,lsri) },
5575 
  { FR30BF_INSN_LSR2, SEM_FN_NAME (fr30bf,lsr2) },
5576 
  { FR30BF_INSN_ASR, SEM_FN_NAME (fr30bf,asr) },
5577 
  { FR30BF_INSN_ASRI, SEM_FN_NAME (fr30bf,asri) },
5578 
  { FR30BF_INSN_ASR2, SEM_FN_NAME (fr30bf,asr2) },
5579 
  { FR30BF_INSN_LDI8, SEM_FN_NAME (fr30bf,ldi8) },
5580 
  { FR30BF_INSN_LDI20, SEM_FN_NAME (fr30bf,ldi20) },
5581 
  { FR30BF_INSN_LDI32, SEM_FN_NAME (fr30bf,ldi32) },
5582 
  { FR30BF_INSN_LD, SEM_FN_NAME (fr30bf,ld) },
5583 
  { FR30BF_INSN_LDUH, SEM_FN_NAME (fr30bf,lduh) },
5584 
  { FR30BF_INSN_LDUB, SEM_FN_NAME (fr30bf,ldub) },
5585 
  { FR30BF_INSN_LDR13, SEM_FN_NAME (fr30bf,ldr13) },
5586 
  { FR30BF_INSN_LDR13UH, SEM_FN_NAME (fr30bf,ldr13uh) },
5587 
  { FR30BF_INSN_LDR13UB, SEM_FN_NAME (fr30bf,ldr13ub) },
5588 
  { FR30BF_INSN_LDR14, SEM_FN_NAME (fr30bf,ldr14) },
5589 
  { FR30BF_INSN_LDR14UH, SEM_FN_NAME (fr30bf,ldr14uh) },
5590 
  { FR30BF_INSN_LDR14UB, SEM_FN_NAME (fr30bf,ldr14ub) },
5591 
  { FR30BF_INSN_LDR15, SEM_FN_NAME (fr30bf,ldr15) },
5592 
  { FR30BF_INSN_LDR15GR, SEM_FN_NAME (fr30bf,ldr15gr) },
5593 
  { FR30BF_INSN_LDR15DR, SEM_FN_NAME (fr30bf,ldr15dr) },
5594 
  { FR30BF_INSN_LDR15PS, SEM_FN_NAME (fr30bf,ldr15ps) },
5595 
  { FR30BF_INSN_ST, SEM_FN_NAME (fr30bf,st) },
5596 
  { FR30BF_INSN_STH, SEM_FN_NAME (fr30bf,sth) },
5597 
  { FR30BF_INSN_STB, SEM_FN_NAME (fr30bf,stb) },
5598 
  { FR30BF_INSN_STR13, SEM_FN_NAME (fr30bf,str13) },
5599 
  { FR30BF_INSN_STR13H, SEM_FN_NAME (fr30bf,str13h) },
5600 
  { FR30BF_INSN_STR13B, SEM_FN_NAME (fr30bf,str13b) },
5601 
  { FR30BF_INSN_STR14, SEM_FN_NAME (fr30bf,str14) },
5602 
  { FR30BF_INSN_STR14H, SEM_FN_NAME (fr30bf,str14h) },
5603 
  { FR30BF_INSN_STR14B, SEM_FN_NAME (fr30bf,str14b) },
5604 
  { FR30BF_INSN_STR15, SEM_FN_NAME (fr30bf,str15) },
5605 
  { FR30BF_INSN_STR15GR, SEM_FN_NAME (fr30bf,str15gr) },
5606 
  { FR30BF_INSN_STR15DR, SEM_FN_NAME (fr30bf,str15dr) },
5607 
  { FR30BF_INSN_STR15PS, SEM_FN_NAME (fr30bf,str15ps) },
5608 
  { FR30BF_INSN_MOV, SEM_FN_NAME (fr30bf,mov) },
5609 
  { FR30BF_INSN_MOVDR, SEM_FN_NAME (fr30bf,movdr) },
5610 
  { FR30BF_INSN_MOVPS, SEM_FN_NAME (fr30bf,movps) },
5611 
  { FR30BF_INSN_MOV2DR, SEM_FN_NAME (fr30bf,mov2dr) },
5612 
  { FR30BF_INSN_MOV2PS, SEM_FN_NAME (fr30bf,mov2ps) },
5613 
  { FR30BF_INSN_JMP, SEM_FN_NAME (fr30bf,jmp) },
5614 
  { FR30BF_INSN_JMPD, SEM_FN_NAME (fr30bf,jmpd) },
5615 
  { FR30BF_INSN_CALLR, SEM_FN_NAME (fr30bf,callr) },
5616 
  { FR30BF_INSN_CALLRD, SEM_FN_NAME (fr30bf,callrd) },
5617 
  { FR30BF_INSN_CALL, SEM_FN_NAME (fr30bf,call) },
5618 
  { FR30BF_INSN_CALLD, SEM_FN_NAME (fr30bf,calld) },
5619 
  { FR30BF_INSN_RET, SEM_FN_NAME (fr30bf,ret) },
5620 
  { FR30BF_INSN_RET_D, SEM_FN_NAME (fr30bf,ret_d) },
5621 
  { FR30BF_INSN_INT, SEM_FN_NAME (fr30bf,int) },
5622 
  { FR30BF_INSN_INTE, SEM_FN_NAME (fr30bf,inte) },
5623 
  { FR30BF_INSN_RETI, SEM_FN_NAME (fr30bf,reti) },
5624 
  { FR30BF_INSN_BRAD, SEM_FN_NAME (fr30bf,brad) },
5625 
  { FR30BF_INSN_BRA, SEM_FN_NAME (fr30bf,bra) },
5626 
  { FR30BF_INSN_BNOD, SEM_FN_NAME (fr30bf,bnod) },
5627 
  { FR30BF_INSN_BNO, SEM_FN_NAME (fr30bf,bno) },
5628 
  { FR30BF_INSN_BEQD, SEM_FN_NAME (fr30bf,beqd) },
5629 
  { FR30BF_INSN_BEQ, SEM_FN_NAME (fr30bf,beq) },
5630 
  { FR30BF_INSN_BNED, SEM_FN_NAME (fr30bf,bned) },
5631 
  { FR30BF_INSN_BNE, SEM_FN_NAME (fr30bf,bne) },
5632 
  { FR30BF_INSN_BCD, SEM_FN_NAME (fr30bf,bcd) },
5633 
  { FR30BF_INSN_BC, SEM_FN_NAME (fr30bf,bc) },
5634 
  { FR30BF_INSN_BNCD, SEM_FN_NAME (fr30bf,bncd) },
5635 
  { FR30BF_INSN_BNC, SEM_FN_NAME (fr30bf,bnc) },
5636 
  { FR30BF_INSN_BND, SEM_FN_NAME (fr30bf,bnd) },
5637 
  { FR30BF_INSN_BN, SEM_FN_NAME (fr30bf,bn) },
5638 
  { FR30BF_INSN_BPD, SEM_FN_NAME (fr30bf,bpd) },
5639 
  { FR30BF_INSN_BP, SEM_FN_NAME (fr30bf,bp) },
5640 
  { FR30BF_INSN_BVD, SEM_FN_NAME (fr30bf,bvd) },
5641 
  { FR30BF_INSN_BV, SEM_FN_NAME (fr30bf,bv) },
5642 
  { FR30BF_INSN_BNVD, SEM_FN_NAME (fr30bf,bnvd) },
5643 
  { FR30BF_INSN_BNV, SEM_FN_NAME (fr30bf,bnv) },
5644 
  { FR30BF_INSN_BLTD, SEM_FN_NAME (fr30bf,bltd) },
5645 
  { FR30BF_INSN_BLT, SEM_FN_NAME (fr30bf,blt) },
5646 
  { FR30BF_INSN_BGED, SEM_FN_NAME (fr30bf,bged) },
5647 
  { FR30BF_INSN_BGE, SEM_FN_NAME (fr30bf,bge) },
5648 
  { FR30BF_INSN_BLED, SEM_FN_NAME (fr30bf,bled) },
5649 
  { FR30BF_INSN_BLE, SEM_FN_NAME (fr30bf,ble) },
5650 
  { FR30BF_INSN_BGTD, SEM_FN_NAME (fr30bf,bgtd) },
5651 
  { FR30BF_INSN_BGT, SEM_FN_NAME (fr30bf,bgt) },
5652 
  { FR30BF_INSN_BLSD, SEM_FN_NAME (fr30bf,blsd) },
5653 
  { FR30BF_INSN_BLS, SEM_FN_NAME (fr30bf,bls) },
5654 
  { FR30BF_INSN_BHID, SEM_FN_NAME (fr30bf,bhid) },
5655 
  { FR30BF_INSN_BHI, SEM_FN_NAME (fr30bf,bhi) },
5656 
  { FR30BF_INSN_DMOVR13, SEM_FN_NAME (fr30bf,dmovr13) },
5657 
  { FR30BF_INSN_DMOVR13H, SEM_FN_NAME (fr30bf,dmovr13h) },
5658 
  { FR30BF_INSN_DMOVR13B, SEM_FN_NAME (fr30bf,dmovr13b) },
5659 
  { FR30BF_INSN_DMOVR13PI, SEM_FN_NAME (fr30bf,dmovr13pi) },
5660 
  { FR30BF_INSN_DMOVR13PIH, SEM_FN_NAME (fr30bf,dmovr13pih) },
5661 
  { FR30BF_INSN_DMOVR13PIB, SEM_FN_NAME (fr30bf,dmovr13pib) },
5662 
  { FR30BF_INSN_DMOVR15PI, SEM_FN_NAME (fr30bf,dmovr15pi) },
5663 
  { FR30BF_INSN_DMOV2R13, SEM_FN_NAME (fr30bf,dmov2r13) },
5664 
  { FR30BF_INSN_DMOV2R13H, SEM_FN_NAME (fr30bf,dmov2r13h) },
5665 
  { FR30BF_INSN_DMOV2R13B, SEM_FN_NAME (fr30bf,dmov2r13b) },
5666 
  { FR30BF_INSN_DMOV2R13PI, SEM_FN_NAME (fr30bf,dmov2r13pi) },
5667 
  { FR30BF_INSN_DMOV2R13PIH, SEM_FN_NAME (fr30bf,dmov2r13pih) },
5668 
  { FR30BF_INSN_DMOV2R13PIB, SEM_FN_NAME (fr30bf,dmov2r13pib) },
5669 
  { FR30BF_INSN_DMOV2R15PD, SEM_FN_NAME (fr30bf,dmov2r15pd) },
5670 
  { FR30BF_INSN_LDRES, SEM_FN_NAME (fr30bf,ldres) },
5671 
  { FR30BF_INSN_STRES, SEM_FN_NAME (fr30bf,stres) },
5672 
  { FR30BF_INSN_COPOP, SEM_FN_NAME (fr30bf,copop) },
5673 
  { FR30BF_INSN_COPLD, SEM_FN_NAME (fr30bf,copld) },
5674 
  { FR30BF_INSN_COPST, SEM_FN_NAME (fr30bf,copst) },
5675 
  { FR30BF_INSN_COPSV, SEM_FN_NAME (fr30bf,copsv) },
5676 
  { FR30BF_INSN_NOP, SEM_FN_NAME (fr30bf,nop) },
5677 
  { FR30BF_INSN_ANDCCR, SEM_FN_NAME (fr30bf,andccr) },
5678 
  { FR30BF_INSN_ORCCR, SEM_FN_NAME (fr30bf,orccr) },
5679 
  { FR30BF_INSN_STILM, SEM_FN_NAME (fr30bf,stilm) },
5680 
  { FR30BF_INSN_ADDSP, SEM_FN_NAME (fr30bf,addsp) },
5681 
  { FR30BF_INSN_EXTSB, SEM_FN_NAME (fr30bf,extsb) },
5682 
  { FR30BF_INSN_EXTUB, SEM_FN_NAME (fr30bf,extub) },
5683 
  { FR30BF_INSN_EXTSH, SEM_FN_NAME (fr30bf,extsh) },
5684 
  { FR30BF_INSN_EXTUH, SEM_FN_NAME (fr30bf,extuh) },
5685 
  { FR30BF_INSN_LDM0, SEM_FN_NAME (fr30bf,ldm0) },
5686 
  { FR30BF_INSN_LDM1, SEM_FN_NAME (fr30bf,ldm1) },
5687 
  { FR30BF_INSN_STM0, SEM_FN_NAME (fr30bf,stm0) },
5688 
  { FR30BF_INSN_STM1, SEM_FN_NAME (fr30bf,stm1) },
5689 
  { FR30BF_INSN_ENTER, SEM_FN_NAME (fr30bf,enter) },
5690 
  { FR30BF_INSN_LEAVE, SEM_FN_NAME (fr30bf,leave) },
5691 
  { FR30BF_INSN_XCHB, SEM_FN_NAME (fr30bf,xchb) },
5692 
  { 0, 0 }
5693 
};
5694 
 
5695 
/* Add the semantic fns to IDESC_TABLE.  */
5696 
 
5697 
void
5698 
SEM_FN_NAME (fr30bf,init_idesc_table) (SIM_CPU *current_cpu)
5699 
{
5700 
  IDESC *idesc_table = CPU_IDESC (current_cpu);
5701 
  const struct sem_fn_desc *sf;
5702 
  int mach_num = MACH_NUM (CPU_MACH (current_cpu));
5703 
 
5704 
  for (sf = &sem_fns[0]; sf->fn != 0; ++sf)
5705 
    {
5706 
      const CGEN_INSN *insn = idesc_table[sf->index].idata;
5707 
      int valid_p = (CGEN_INSN_VIRTUAL_P (insn)
5708 
                     || CGEN_INSN_MACH_HAS_P (insn, mach_num));
5709 
#if FAST_P
5710 
      if (valid_p)
5711 
        idesc_table[sf->index].sem_fast = sf->fn;
5712 
      else
5713 
        idesc_table[sf->index].sem_fast = SEM_FN_NAME (fr30bf,x_invalid);
5714 
#else
5715 
      if (valid_p)
5716 
        idesc_table[sf->index].sem_full = sf->fn;
5717 
      else
5718 
        idesc_table[sf->index].sem_full = SEM_FN_NAME (fr30bf,x_invalid);
5719 
#endif
5720 
    }
5721 
}
5722 
 

powered by: WebSVN 2.1.0

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