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