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

Subversion Repositories scarts

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

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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