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