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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.2/] [sim/] [sh64/] [sem-media.c] - Blame information for rev 381

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 jeremybenn 
/* Simulator instruction semantics for sh64.
2 
 
3 
THIS FILE IS MACHINE GENERATED WITH CGEN.
4 
 
5 
Copyright 1996-2010 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, write to the Free Software Foundation, Inc.,
21 
   51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
22 
 
23 
*/
24 
 
25 
#define WANT_CPU sh64
26 
#define WANT_CPU_SH64
27 
 
28 
#include "sim-main.h"
29 
#include "cgen-mem.h"
30 
#include "cgen-ops.h"
31 
 
32 
#undef GET_ATTR
33 
#define GET_ATTR(cpu, num, attr) CGEN_ATTR_VALUE (NULL, abuf->idesc->attrs, CGEN_INSN_##attr)
34 
 
35 
/* This is used so that we can compile two copies of the semantic code,
36 
   one with full feature support and one without that runs fast(er).
37 
   FAST_P, when desired, is defined on the command line, -DFAST_P=1.  */
38 
#if FAST_P
39 
#define SEM_FN_NAME(cpu,fn) XCONCAT3 (cpu,_semf_,fn)
40 
#undef TRACE_RESULT
41 
#define TRACE_RESULT(cpu, abuf, name, type, val)
42 
#else
43 
#define SEM_FN_NAME(cpu,fn) XCONCAT3 (cpu,_sem_,fn)
44 
#endif
45 
 
46 
/* x-invalid: --invalid-- */
47 
 
48 
static SEM_PC
49 
SEM_FN_NAME (sh64_media,x_invalid) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
50 
{
51 
#define FLD(f) abuf->fields.sfmt_empty.f
52 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
53 
  int UNUSED written = 0;
54 
  IADDR UNUSED pc = abuf->addr;
55 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
56 
 
57 
  {
58 
    /* Update the recorded pc in the cpu state struct.
59 
       Only necessary for WITH_SCACHE case, but to avoid the
60 
       conditional compilation ....  */
61 
    SET_H_PC (pc);
62 
    /* Virtual insns have zero size.  Overwrite vpc with address of next insn
63 
       using the default-insn-bitsize spec.  When executing insns in parallel
64 
       we may want to queue the fault and continue execution.  */
65 
    vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
66 
    vpc = sim_engine_invalid_insn (current_cpu, pc, vpc);
67 
  }
68 
 
69 
  return vpc;
70 
#undef FLD
71 
}
72 
 
73 
/* x-after: --after-- */
74 
 
75 
static SEM_PC
76 
SEM_FN_NAME (sh64_media,x_after) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
77 
{
78 
#define FLD(f) abuf->fields.sfmt_empty.f
79 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
80 
  int UNUSED written = 0;
81 
  IADDR UNUSED pc = abuf->addr;
82 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
83 
 
84 
  {
85 
#if WITH_SCACHE_PBB_SH64_MEDIA
86 
    sh64_media_pbb_after (current_cpu, sem_arg);
87 
#endif
88 
  }
89 
 
90 
  return vpc;
91 
#undef FLD
92 
}
93 
 
94 
/* x-before: --before-- */
95 
 
96 
static SEM_PC
97 
SEM_FN_NAME (sh64_media,x_before) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
98 
{
99 
#define FLD(f) abuf->fields.sfmt_empty.f
100 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
101 
  int UNUSED written = 0;
102 
  IADDR UNUSED pc = abuf->addr;
103 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
104 
 
105 
  {
106 
#if WITH_SCACHE_PBB_SH64_MEDIA
107 
    sh64_media_pbb_before (current_cpu, sem_arg);
108 
#endif
109 
  }
110 
 
111 
  return vpc;
112 
#undef FLD
113 
}
114 
 
115 
/* x-cti-chain: --cti-chain-- */
116 
 
117 
static SEM_PC
118 
SEM_FN_NAME (sh64_media,x_cti_chain) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
119 
{
120 
#define FLD(f) abuf->fields.sfmt_empty.f
121 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
122 
  int UNUSED written = 0;
123 
  IADDR UNUSED pc = abuf->addr;
124 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
125 
 
126 
  {
127 
#if WITH_SCACHE_PBB_SH64_MEDIA
128 
#ifdef DEFINE_SWITCH
129 
    vpc = sh64_media_pbb_cti_chain (current_cpu, sem_arg,
130 
                               pbb_br_type, pbb_br_npc);
131 
    BREAK (sem);
132 
#else
133 
    /* FIXME: Allow provision of explicit ifmt spec in insn spec.  */
134 
    vpc = sh64_media_pbb_cti_chain (current_cpu, sem_arg,
135 
                               CPU_PBB_BR_TYPE (current_cpu),
136 
                               CPU_PBB_BR_NPC (current_cpu));
137 
#endif
138 
#endif
139 
  }
140 
 
141 
  return vpc;
142 
#undef FLD
143 
}
144 
 
145 
/* x-chain: --chain-- */
146 
 
147 
static SEM_PC
148 
SEM_FN_NAME (sh64_media,x_chain) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
149 
{
150 
#define FLD(f) abuf->fields.sfmt_empty.f
151 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
152 
  int UNUSED written = 0;
153 
  IADDR UNUSED pc = abuf->addr;
154 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
155 
 
156 
  {
157 
#if WITH_SCACHE_PBB_SH64_MEDIA
158 
    vpc = sh64_media_pbb_chain (current_cpu, sem_arg);
159 
#ifdef DEFINE_SWITCH
160 
    BREAK (sem);
161 
#endif
162 
#endif
163 
  }
164 
 
165 
  return vpc;
166 
#undef FLD
167 
}
168 
 
169 
/* x-begin: --begin-- */
170 
 
171 
static SEM_PC
172 
SEM_FN_NAME (sh64_media,x_begin) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
173 
{
174 
#define FLD(f) abuf->fields.sfmt_empty.f
175 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
176 
  int UNUSED written = 0;
177 
  IADDR UNUSED pc = abuf->addr;
178 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
179 
 
180 
  {
181 
#if WITH_SCACHE_PBB_SH64_MEDIA
182 
#if defined DEFINE_SWITCH || defined FAST_P
183 
    /* In the switch case FAST_P is a constant, allowing several optimizations
184 
       in any called inline functions.  */
185 
    vpc = sh64_media_pbb_begin (current_cpu, FAST_P);
186 
#else
187 
#if 0 /* cgen engine can't handle dynamic fast/full switching yet.  */
188 
    vpc = sh64_media_pbb_begin (current_cpu, STATE_RUN_FAST_P (CPU_STATE (current_cpu)));
189 
#else
190 
    vpc = sh64_media_pbb_begin (current_cpu, 0);
191 
#endif
192 
#endif
193 
#endif
194 
  }
195 
 
196 
  return vpc;
197 
#undef FLD
198 
}
199 
 
200 
/* add: add $rm, $rn, $rd */
201 
 
202 
static SEM_PC
203 
SEM_FN_NAME (sh64_media,add) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
204 
{
205 
#define FLD(f) abuf->fields.sfmt_add.f
206 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
207 
  int UNUSED written = 0;
208 
  IADDR UNUSED pc = abuf->addr;
209 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
210 
 
211 
  {
212 
    DI opval = ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)));
213 
    SET_H_GR (FLD (f_dest), opval);
214 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
215 
  }
216 
 
217 
  return vpc;
218 
#undef FLD
219 
}
220 
 
221 
/* addl: add.l $rm, $rn, $rd */
222 
 
223 
static SEM_PC
224 
SEM_FN_NAME (sh64_media,addl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
225 
{
226 
#define FLD(f) abuf->fields.sfmt_add.f
227 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
228 
  int UNUSED written = 0;
229 
  IADDR UNUSED pc = abuf->addr;
230 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
231 
 
232 
  {
233 
    DI opval = ADDSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), SUBWORDDISI (GET_H_GR (FLD (f_right)), 1));
234 
    SET_H_GR (FLD (f_dest), opval);
235 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
236 
  }
237 
 
238 
  return vpc;
239 
#undef FLD
240 
}
241 
 
242 
/* addi: addi $rm, $disp10, $rd */
243 
 
244 
static SEM_PC
245 
SEM_FN_NAME (sh64_media,addi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
246 
{
247 
#define FLD(f) abuf->fields.sfmt_addi.f
248 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
249 
  int UNUSED written = 0;
250 
  IADDR UNUSED pc = abuf->addr;
251 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
252 
 
253 
  {
254 
    DI opval = ADDDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_disp10)));
255 
    SET_H_GR (FLD (f_dest), opval);
256 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
257 
  }
258 
 
259 
  return vpc;
260 
#undef FLD
261 
}
262 
 
263 
/* addil: addi.l $rm, $disp10, $rd */
264 
 
265 
static SEM_PC
266 
SEM_FN_NAME (sh64_media,addil) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
267 
{
268 
#define FLD(f) abuf->fields.sfmt_addi.f
269 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
270 
  int UNUSED written = 0;
271 
  IADDR UNUSED pc = abuf->addr;
272 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
273 
 
274 
  {
275 
    DI opval = EXTSIDI (ADDSI (EXTSISI (FLD (f_disp10)), SUBWORDDISI (GET_H_GR (FLD (f_left)), 1)));
276 
    SET_H_GR (FLD (f_dest), opval);
277 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
278 
  }
279 
 
280 
  return vpc;
281 
#undef FLD
282 
}
283 
 
284 
/* addzl: addz.l $rm, $rn, $rd */
285 
 
286 
static SEM_PC
287 
SEM_FN_NAME (sh64_media,addzl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
288 
{
289 
#define FLD(f) abuf->fields.sfmt_add.f
290 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
291 
  int UNUSED written = 0;
292 
  IADDR UNUSED pc = abuf->addr;
293 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
294 
 
295 
  {
296 
    DI opval = ZEXTSIDI (ADDSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), SUBWORDDISI (GET_H_GR (FLD (f_right)), 1)));
297 
    SET_H_GR (FLD (f_dest), opval);
298 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
299 
  }
300 
 
301 
  return vpc;
302 
#undef FLD
303 
}
304 
 
305 
/* alloco: alloco $rm, $disp6x32 */
306 
 
307 
static SEM_PC
308 
SEM_FN_NAME (sh64_media,alloco) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
309 
{
310 
#define FLD(f) abuf->fields.sfmt_xori.f
311 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
312 
  int UNUSED written = 0;
313 
  IADDR UNUSED pc = abuf->addr;
314 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
315 
 
316 
{
317 
  {
318 
    DI opval = GET_H_GR (FLD (f_left));
319 
    SET_H_GR (FLD (f_left), opval);
320 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
321 
  }
322 
((void) 0); /*nop*/
323 
}
324 
 
325 
  return vpc;
326 
#undef FLD
327 
}
328 
 
329 
/* and: and $rm, $rn, $rd */
330 
 
331 
static SEM_PC
332 
SEM_FN_NAME (sh64_media,and) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
333 
{
334 
#define FLD(f) abuf->fields.sfmt_add.f
335 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
336 
  int UNUSED written = 0;
337 
  IADDR UNUSED pc = abuf->addr;
338 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
339 
 
340 
  {
341 
    DI opval = ANDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)));
342 
    SET_H_GR (FLD (f_dest), opval);
343 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
344 
  }
345 
 
346 
  return vpc;
347 
#undef FLD
348 
}
349 
 
350 
/* andc: andc $rm, $rn, $rd */
351 
 
352 
static SEM_PC
353 
SEM_FN_NAME (sh64_media,andc) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
354 
{
355 
#define FLD(f) abuf->fields.sfmt_add.f
356 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
357 
  int UNUSED written = 0;
358 
  IADDR UNUSED pc = abuf->addr;
359 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
360 
 
361 
  {
362 
    DI opval = ANDDI (GET_H_GR (FLD (f_left)), INVDI (GET_H_GR (FLD (f_right))));
363 
    SET_H_GR (FLD (f_dest), opval);
364 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
365 
  }
366 
 
367 
  return vpc;
368 
#undef FLD
369 
}
370 
 
371 
/* andi: andi $rm, $disp10, $rd */
372 
 
373 
static SEM_PC
374 
SEM_FN_NAME (sh64_media,andi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
375 
{
376 
#define FLD(f) abuf->fields.sfmt_addi.f
377 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
378 
  int UNUSED written = 0;
379 
  IADDR UNUSED pc = abuf->addr;
380 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
381 
 
382 
  {
383 
    DI opval = ANDDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_disp10)));
384 
    SET_H_GR (FLD (f_dest), opval);
385 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
386 
  }
387 
 
388 
  return vpc;
389 
#undef FLD
390 
}
391 
 
392 
/* beq: beq$likely $rm, $rn, $tra */
393 
 
394 
static SEM_PC
395 
SEM_FN_NAME (sh64_media,beq) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
396 
{
397 
#define FLD(f) abuf->fields.sfmt_beq.f
398 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
399 
  int UNUSED written = 0;
400 
  IADDR UNUSED pc = abuf->addr;
401 
  SEM_BRANCH_INIT
402 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
403 
 
404 
{
405 
((void) 0); /*nop*/
406 
if (EQDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))) {
407 
  {
408 
    UDI opval = CPU (h_tr[FLD (f_tra)]);
409 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
410 
    written |= (1 << 3);
411 
    TRACE_RESULT (current_cpu, abuf, "pc", 'D', opval);
412 
  }
413 
}
414 
}
415 
 
416 
  abuf->written = written;
417 
  SEM_BRANCH_FINI (vpc);
418 
  return vpc;
419 
#undef FLD
420 
}
421 
 
422 
/* beqi: beqi$likely $rm, $imm6, $tra */
423 
 
424 
static SEM_PC
425 
SEM_FN_NAME (sh64_media,beqi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
426 
{
427 
#define FLD(f) abuf->fields.sfmt_beqi.f
428 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
429 
  int UNUSED written = 0;
430 
  IADDR UNUSED pc = abuf->addr;
431 
  SEM_BRANCH_INIT
432 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
433 
 
434 
{
435 
((void) 0); /*nop*/
436 
if (EQDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_imm6)))) {
437 
  {
438 
    UDI opval = CPU (h_tr[FLD (f_tra)]);
439 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
440 
    written |= (1 << 3);
441 
    TRACE_RESULT (current_cpu, abuf, "pc", 'D', opval);
442 
  }
443 
}
444 
}
445 
 
446 
  abuf->written = written;
447 
  SEM_BRANCH_FINI (vpc);
448 
  return vpc;
449 
#undef FLD
450 
}
451 
 
452 
/* bge: bge$likely $rm, $rn, $tra */
453 
 
454 
static SEM_PC
455 
SEM_FN_NAME (sh64_media,bge) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
456 
{
457 
#define FLD(f) abuf->fields.sfmt_beq.f
458 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
459 
  int UNUSED written = 0;
460 
  IADDR UNUSED pc = abuf->addr;
461 
  SEM_BRANCH_INIT
462 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
463 
 
464 
{
465 
((void) 0); /*nop*/
466 
if (GEDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))) {
467 
  {
468 
    UDI opval = CPU (h_tr[FLD (f_tra)]);
469 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
470 
    written |= (1 << 3);
471 
    TRACE_RESULT (current_cpu, abuf, "pc", 'D', opval);
472 
  }
473 
}
474 
}
475 
 
476 
  abuf->written = written;
477 
  SEM_BRANCH_FINI (vpc);
478 
  return vpc;
479 
#undef FLD
480 
}
481 
 
482 
/* bgeu: bgeu$likely $rm, $rn, $tra */
483 
 
484 
static SEM_PC
485 
SEM_FN_NAME (sh64_media,bgeu) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
486 
{
487 
#define FLD(f) abuf->fields.sfmt_beq.f
488 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
489 
  int UNUSED written = 0;
490 
  IADDR UNUSED pc = abuf->addr;
491 
  SEM_BRANCH_INIT
492 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
493 
 
494 
{
495 
((void) 0); /*nop*/
496 
if (GEUDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))) {
497 
  {
498 
    UDI opval = CPU (h_tr[FLD (f_tra)]);
499 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
500 
    written |= (1 << 3);
501 
    TRACE_RESULT (current_cpu, abuf, "pc", 'D', opval);
502 
  }
503 
}
504 
}
505 
 
506 
  abuf->written = written;
507 
  SEM_BRANCH_FINI (vpc);
508 
  return vpc;
509 
#undef FLD
510 
}
511 
 
512 
/* bgt: bgt$likely $rm, $rn, $tra */
513 
 
514 
static SEM_PC
515 
SEM_FN_NAME (sh64_media,bgt) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
516 
{
517 
#define FLD(f) abuf->fields.sfmt_beq.f
518 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
519 
  int UNUSED written = 0;
520 
  IADDR UNUSED pc = abuf->addr;
521 
  SEM_BRANCH_INIT
522 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
523 
 
524 
{
525 
((void) 0); /*nop*/
526 
if (GTDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))) {
527 
  {
528 
    UDI opval = CPU (h_tr[FLD (f_tra)]);
529 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
530 
    written |= (1 << 3);
531 
    TRACE_RESULT (current_cpu, abuf, "pc", 'D', opval);
532 
  }
533 
}
534 
}
535 
 
536 
  abuf->written = written;
537 
  SEM_BRANCH_FINI (vpc);
538 
  return vpc;
539 
#undef FLD
540 
}
541 
 
542 
/* bgtu: bgtu$likely $rm, $rn, $tra */
543 
 
544 
static SEM_PC
545 
SEM_FN_NAME (sh64_media,bgtu) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
546 
{
547 
#define FLD(f) abuf->fields.sfmt_beq.f
548 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
549 
  int UNUSED written = 0;
550 
  IADDR UNUSED pc = abuf->addr;
551 
  SEM_BRANCH_INIT
552 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
553 
 
554 
{
555 
((void) 0); /*nop*/
556 
if (GTUDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))) {
557 
  {
558 
    UDI opval = CPU (h_tr[FLD (f_tra)]);
559 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
560 
    written |= (1 << 3);
561 
    TRACE_RESULT (current_cpu, abuf, "pc", 'D', opval);
562 
  }
563 
}
564 
}
565 
 
566 
  abuf->written = written;
567 
  SEM_BRANCH_FINI (vpc);
568 
  return vpc;
569 
#undef FLD
570 
}
571 
 
572 
/* blink: blink $trb, $rd */
573 
 
574 
static SEM_PC
575 
SEM_FN_NAME (sh64_media,blink) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
576 
{
577 
#define FLD(f) abuf->fields.sfmt_blink.f
578 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
579 
  int UNUSED written = 0;
580 
  IADDR UNUSED pc = abuf->addr;
581 
  SEM_BRANCH_INIT
582 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
583 
 
584 
{
585 
  {
586 
    DI opval = ORDI (ADDDI (pc, 4), 1);
587 
    SET_H_GR (FLD (f_dest), opval);
588 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
589 
  }
590 
  {
591 
    UDI opval = CPU (h_tr[FLD (f_trb)]);
592 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
593 
    TRACE_RESULT (current_cpu, abuf, "pc", 'D', opval);
594 
  }
595 
if (EQSI (FLD (f_dest), 63)) {
596 
((void) 0); /*nop*/
597 
} else {
598 
((void) 0); /*nop*/
599 
}
600 
}
601 
 
602 
  SEM_BRANCH_FINI (vpc);
603 
  return vpc;
604 
#undef FLD
605 
}
606 
 
607 
/* bne: bne$likely $rm, $rn, $tra */
608 
 
609 
static SEM_PC
610 
SEM_FN_NAME (sh64_media,bne) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
611 
{
612 
#define FLD(f) abuf->fields.sfmt_beq.f
613 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
614 
  int UNUSED written = 0;
615 
  IADDR UNUSED pc = abuf->addr;
616 
  SEM_BRANCH_INIT
617 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
618 
 
619 
{
620 
((void) 0); /*nop*/
621 
if (NEDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))) {
622 
  {
623 
    UDI opval = CPU (h_tr[FLD (f_tra)]);
624 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
625 
    written |= (1 << 3);
626 
    TRACE_RESULT (current_cpu, abuf, "pc", 'D', opval);
627 
  }
628 
}
629 
}
630 
 
631 
  abuf->written = written;
632 
  SEM_BRANCH_FINI (vpc);
633 
  return vpc;
634 
#undef FLD
635 
}
636 
 
637 
/* bnei: bnei$likely $rm, $imm6, $tra */
638 
 
639 
static SEM_PC
640 
SEM_FN_NAME (sh64_media,bnei) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
641 
{
642 
#define FLD(f) abuf->fields.sfmt_beqi.f
643 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
644 
  int UNUSED written = 0;
645 
  IADDR UNUSED pc = abuf->addr;
646 
  SEM_BRANCH_INIT
647 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
648 
 
649 
{
650 
((void) 0); /*nop*/
651 
if (NEDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_imm6)))) {
652 
  {
653 
    UDI opval = CPU (h_tr[FLD (f_tra)]);
654 
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
655 
    written |= (1 << 3);
656 
    TRACE_RESULT (current_cpu, abuf, "pc", 'D', opval);
657 
  }
658 
}
659 
}
660 
 
661 
  abuf->written = written;
662 
  SEM_BRANCH_FINI (vpc);
663 
  return vpc;
664 
#undef FLD
665 
}
666 
 
667 
/* brk: brk */
668 
 
669 
static SEM_PC
670 
SEM_FN_NAME (sh64_media,brk) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
671 
{
672 
#define FLD(f) abuf->fields.sfmt_empty.f
673 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
674 
  int UNUSED written = 0;
675 
  IADDR UNUSED pc = abuf->addr;
676 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
677 
 
678 
sh64_break (current_cpu, pc);
679 
 
680 
  return vpc;
681 
#undef FLD
682 
}
683 
 
684 
/* byterev: byterev $rm, $rd */
685 
 
686 
static SEM_PC
687 
SEM_FN_NAME (sh64_media,byterev) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
688 
{
689 
#define FLD(f) abuf->fields.sfmt_xori.f
690 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
691 
  int UNUSED written = 0;
692 
  IADDR UNUSED pc = abuf->addr;
693 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
694 
 
695 
{
696 
  DI tmp_source;
697 
  DI tmp_result;
698 
  tmp_source = GET_H_GR (FLD (f_left));
699 
  tmp_result = 0;
700 
{
701 
  tmp_result = ORDI (SLLDI (tmp_result, 8), ANDDI (tmp_source, 255));
702 
  tmp_source = SRLDI (tmp_source, 8);
703 
}
704 
{
705 
  tmp_result = ORDI (SLLDI (tmp_result, 8), ANDDI (tmp_source, 255));
706 
  tmp_source = SRLDI (tmp_source, 8);
707 
}
708 
{
709 
  tmp_result = ORDI (SLLDI (tmp_result, 8), ANDDI (tmp_source, 255));
710 
  tmp_source = SRLDI (tmp_source, 8);
711 
}
712 
{
713 
  tmp_result = ORDI (SLLDI (tmp_result, 8), ANDDI (tmp_source, 255));
714 
  tmp_source = SRLDI (tmp_source, 8);
715 
}
716 
{
717 
  tmp_result = ORDI (SLLDI (tmp_result, 8), ANDDI (tmp_source, 255));
718 
  tmp_source = SRLDI (tmp_source, 8);
719 
}
720 
{
721 
  tmp_result = ORDI (SLLDI (tmp_result, 8), ANDDI (tmp_source, 255));
722 
  tmp_source = SRLDI (tmp_source, 8);
723 
}
724 
{
725 
  tmp_result = ORDI (SLLDI (tmp_result, 8), ANDDI (tmp_source, 255));
726 
  tmp_source = SRLDI (tmp_source, 8);
727 
}
728 
{
729 
  tmp_result = ORDI (SLLDI (tmp_result, 8), ANDDI (tmp_source, 255));
730 
  tmp_source = SRLDI (tmp_source, 8);
731 
}
732 
  {
733 
    DI opval = tmp_result;
734 
    SET_H_GR (FLD (f_dest), opval);
735 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
736 
  }
737 
}
738 
 
739 
  return vpc;
740 
#undef FLD
741 
}
742 
 
743 
/* cmpeq: cmpeq $rm, $rn, $rd */
744 
 
745 
static SEM_PC
746 
SEM_FN_NAME (sh64_media,cmpeq) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
747 
{
748 
#define FLD(f) abuf->fields.sfmt_add.f
749 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
750 
  int UNUSED written = 0;
751 
  IADDR UNUSED pc = abuf->addr;
752 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
753 
 
754 
  {
755 
    DI opval = ((EQDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))) ? (1) : (0));
756 
    SET_H_GR (FLD (f_dest), opval);
757 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
758 
  }
759 
 
760 
  return vpc;
761 
#undef FLD
762 
}
763 
 
764 
/* cmpgt: cmpgt $rm, $rn, $rd */
765 
 
766 
static SEM_PC
767 
SEM_FN_NAME (sh64_media,cmpgt) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
768 
{
769 
#define FLD(f) abuf->fields.sfmt_add.f
770 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
771 
  int UNUSED written = 0;
772 
  IADDR UNUSED pc = abuf->addr;
773 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
774 
 
775 
  {
776 
    DI opval = ((GTDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))) ? (1) : (0));
777 
    SET_H_GR (FLD (f_dest), opval);
778 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
779 
  }
780 
 
781 
  return vpc;
782 
#undef FLD
783 
}
784 
 
785 
/* cmpgtu: cmpgtu $rm,$rn, $rd */
786 
 
787 
static SEM_PC
788 
SEM_FN_NAME (sh64_media,cmpgtu) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
789 
{
790 
#define FLD(f) abuf->fields.sfmt_add.f
791 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
792 
  int UNUSED written = 0;
793 
  IADDR UNUSED pc = abuf->addr;
794 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
795 
 
796 
  {
797 
    DI opval = ((GTUDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))) ? (1) : (0));
798 
    SET_H_GR (FLD (f_dest), opval);
799 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
800 
  }
801 
 
802 
  return vpc;
803 
#undef FLD
804 
}
805 
 
806 
/* cmveq: cmveq $rm, $rn, $rd */
807 
 
808 
static SEM_PC
809 
SEM_FN_NAME (sh64_media,cmveq) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
810 
{
811 
#define FLD(f) abuf->fields.sfmt_add.f
812 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
813 
  int UNUSED written = 0;
814 
  IADDR UNUSED pc = abuf->addr;
815 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
816 
 
817 
if (EQDI (GET_H_GR (FLD (f_left)), 0)) {
818 
  {
819 
    DI opval = GET_H_GR (FLD (f_right));
820 
    SET_H_GR (FLD (f_dest), opval);
821 
    written |= (1 << 2);
822 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
823 
  }
824 
}
825 
 
826 
  abuf->written = written;
827 
  return vpc;
828 
#undef FLD
829 
}
830 
 
831 
/* cmvne: cmvne $rm, $rn, $rd */
832 
 
833 
static SEM_PC
834 
SEM_FN_NAME (sh64_media,cmvne) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
835 
{
836 
#define FLD(f) abuf->fields.sfmt_add.f
837 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
838 
  int UNUSED written = 0;
839 
  IADDR UNUSED pc = abuf->addr;
840 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
841 
 
842 
if (NEDI (GET_H_GR (FLD (f_left)), 0)) {
843 
  {
844 
    DI opval = GET_H_GR (FLD (f_right));
845 
    SET_H_GR (FLD (f_dest), opval);
846 
    written |= (1 << 2);
847 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
848 
  }
849 
}
850 
 
851 
  abuf->written = written;
852 
  return vpc;
853 
#undef FLD
854 
}
855 
 
856 
/* fabsd: fabs.d $drgh, $drf */
857 
 
858 
static SEM_PC
859 
SEM_FN_NAME (sh64_media,fabsd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
860 
{
861 
#define FLD(f) abuf->fields.sfmt_fabsd.f
862 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
863 
  int UNUSED written = 0;
864 
  IADDR UNUSED pc = abuf->addr;
865 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
866 
 
867 
  {
868 
    DF opval = sh64_fabsd (current_cpu, GET_H_DR (FLD (f_left_right)));
869 
    SET_H_DR (FLD (f_dest), opval);
870 
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
871 
  }
872 
 
873 
  return vpc;
874 
#undef FLD
875 
}
876 
 
877 
/* fabss: fabs.s $frgh, $frf */
878 
 
879 
static SEM_PC
880 
SEM_FN_NAME (sh64_media,fabss) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
881 
{
882 
#define FLD(f) abuf->fields.sfmt_fabsd.f
883 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
884 
  int UNUSED written = 0;
885 
  IADDR UNUSED pc = abuf->addr;
886 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
887 
 
888 
  {
889 
    SF opval = sh64_fabss (current_cpu, CPU (h_fr[FLD (f_left_right)]));
890 
    CPU (h_fr[FLD (f_dest)]) = opval;
891 
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
892 
  }
893 
 
894 
  return vpc;
895 
#undef FLD
896 
}
897 
 
898 
/* faddd: fadd.d $drg, $drh, $drf */
899 
 
900 
static SEM_PC
901 
SEM_FN_NAME (sh64_media,faddd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
902 
{
903 
#define FLD(f) abuf->fields.sfmt_add.f
904 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
905 
  int UNUSED written = 0;
906 
  IADDR UNUSED pc = abuf->addr;
907 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
908 
 
909 
  {
910 
    DF opval = sh64_faddd (current_cpu, GET_H_DR (FLD (f_left)), GET_H_DR (FLD (f_right)));
911 
    SET_H_DR (FLD (f_dest), opval);
912 
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
913 
  }
914 
 
915 
  return vpc;
916 
#undef FLD
917 
}
918 
 
919 
/* fadds: fadd.s $frg, $frh, $frf */
920 
 
921 
static SEM_PC
922 
SEM_FN_NAME (sh64_media,fadds) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
923 
{
924 
#define FLD(f) abuf->fields.sfmt_add.f
925 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
926 
  int UNUSED written = 0;
927 
  IADDR UNUSED pc = abuf->addr;
928 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
929 
 
930 
  {
931 
    SF opval = sh64_fadds (current_cpu, CPU (h_fr[FLD (f_left)]), CPU (h_fr[FLD (f_right)]));
932 
    CPU (h_fr[FLD (f_dest)]) = opval;
933 
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
934 
  }
935 
 
936 
  return vpc;
937 
#undef FLD
938 
}
939 
 
940 
/* fcmpeqd: fcmpeq.d $drg, $drh, $rd */
941 
 
942 
static SEM_PC
943 
SEM_FN_NAME (sh64_media,fcmpeqd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
944 
{
945 
#define FLD(f) abuf->fields.sfmt_add.f
946 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
947 
  int UNUSED written = 0;
948 
  IADDR UNUSED pc = abuf->addr;
949 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
950 
 
951 
  {
952 
    DI opval = ZEXTBIDI (sh64_fcmpeqd (current_cpu, GET_H_DR (FLD (f_left)), GET_H_DR (FLD (f_right))));
953 
    SET_H_GR (FLD (f_dest), opval);
954 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
955 
  }
956 
 
957 
  return vpc;
958 
#undef FLD
959 
}
960 
 
961 
/* fcmpeqs: fcmpeq.s $frg, $frh, $rd */
962 
 
963 
static SEM_PC
964 
SEM_FN_NAME (sh64_media,fcmpeqs) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
965 
{
966 
#define FLD(f) abuf->fields.sfmt_add.f
967 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
968 
  int UNUSED written = 0;
969 
  IADDR UNUSED pc = abuf->addr;
970 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
971 
 
972 
  {
973 
    DI opval = ZEXTBIDI (sh64_fcmpeqs (current_cpu, CPU (h_fr[FLD (f_left)]), CPU (h_fr[FLD (f_right)])));
974 
    SET_H_GR (FLD (f_dest), opval);
975 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
976 
  }
977 
 
978 
  return vpc;
979 
#undef FLD
980 
}
981 
 
982 
/* fcmpged: fcmpge.d $drg, $drh, $rd */
983 
 
984 
static SEM_PC
985 
SEM_FN_NAME (sh64_media,fcmpged) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
986 
{
987 
#define FLD(f) abuf->fields.sfmt_add.f
988 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
989 
  int UNUSED written = 0;
990 
  IADDR UNUSED pc = abuf->addr;
991 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
992 
 
993 
  {
994 
    DI opval = ZEXTBIDI (sh64_fcmpged (current_cpu, GET_H_DR (FLD (f_left)), GET_H_DR (FLD (f_right))));
995 
    SET_H_GR (FLD (f_dest), opval);
996 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
997 
  }
998 
 
999 
  return vpc;
1000 
#undef FLD
1001 
}
1002 
 
1003 
/* fcmpges: fcmpge.s $frg, $frh, $rd */
1004 
 
1005 
static SEM_PC
1006 
SEM_FN_NAME (sh64_media,fcmpges) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1007 
{
1008 
#define FLD(f) abuf->fields.sfmt_add.f
1009 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1010 
  int UNUSED written = 0;
1011 
  IADDR UNUSED pc = abuf->addr;
1012 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1013 
 
1014 
  {
1015 
    DI opval = ZEXTBIDI (sh64_fcmpges (current_cpu, CPU (h_fr[FLD (f_left)]), CPU (h_fr[FLD (f_right)])));
1016 
    SET_H_GR (FLD (f_dest), opval);
1017 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
1018 
  }
1019 
 
1020 
  return vpc;
1021 
#undef FLD
1022 
}
1023 
 
1024 
/* fcmpgtd: fcmpgt.d $drg, $drh, $rd */
1025 
 
1026 
static SEM_PC
1027 
SEM_FN_NAME (sh64_media,fcmpgtd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1028 
{
1029 
#define FLD(f) abuf->fields.sfmt_add.f
1030 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1031 
  int UNUSED written = 0;
1032 
  IADDR UNUSED pc = abuf->addr;
1033 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1034 
 
1035 
  {
1036 
    DI opval = ZEXTBIDI (sh64_fcmpgtd (current_cpu, GET_H_DR (FLD (f_left)), GET_H_DR (FLD (f_right))));
1037 
    SET_H_GR (FLD (f_dest), opval);
1038 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
1039 
  }
1040 
 
1041 
  return vpc;
1042 
#undef FLD
1043 
}
1044 
 
1045 
/* fcmpgts: fcmpgt.s $frg, $frh, $rd */
1046 
 
1047 
static SEM_PC
1048 
SEM_FN_NAME (sh64_media,fcmpgts) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1049 
{
1050 
#define FLD(f) abuf->fields.sfmt_add.f
1051 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1052 
  int UNUSED written = 0;
1053 
  IADDR UNUSED pc = abuf->addr;
1054 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1055 
 
1056 
  {
1057 
    DI opval = ZEXTBIDI (sh64_fcmpgts (current_cpu, CPU (h_fr[FLD (f_left)]), CPU (h_fr[FLD (f_right)])));
1058 
    SET_H_GR (FLD (f_dest), opval);
1059 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
1060 
  }
1061 
 
1062 
  return vpc;
1063 
#undef FLD
1064 
}
1065 
 
1066 
/* fcmpund: fcmpun.d $drg, $drh, $rd */
1067 
 
1068 
static SEM_PC
1069 
SEM_FN_NAME (sh64_media,fcmpund) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1070 
{
1071 
#define FLD(f) abuf->fields.sfmt_add.f
1072 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1073 
  int UNUSED written = 0;
1074 
  IADDR UNUSED pc = abuf->addr;
1075 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1076 
 
1077 
  {
1078 
    DI opval = ZEXTBIDI (sh64_fcmpund (current_cpu, GET_H_DR (FLD (f_left)), GET_H_DR (FLD (f_right))));
1079 
    SET_H_GR (FLD (f_dest), opval);
1080 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
1081 
  }
1082 
 
1083 
  return vpc;
1084 
#undef FLD
1085 
}
1086 
 
1087 
/* fcmpuns: fcmpun.s $frg, $frh, $rd */
1088 
 
1089 
static SEM_PC
1090 
SEM_FN_NAME (sh64_media,fcmpuns) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1091 
{
1092 
#define FLD(f) abuf->fields.sfmt_add.f
1093 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1094 
  int UNUSED written = 0;
1095 
  IADDR UNUSED pc = abuf->addr;
1096 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1097 
 
1098 
  {
1099 
    DI opval = ZEXTBIDI (sh64_fcmpuns (current_cpu, CPU (h_fr[FLD (f_left)]), CPU (h_fr[FLD (f_right)])));
1100 
    SET_H_GR (FLD (f_dest), opval);
1101 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
1102 
  }
1103 
 
1104 
  return vpc;
1105 
#undef FLD
1106 
}
1107 
 
1108 
/* fcnvds: fcnv.ds $drgh, $frf */
1109 
 
1110 
static SEM_PC
1111 
SEM_FN_NAME (sh64_media,fcnvds) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1112 
{
1113 
#define FLD(f) abuf->fields.sfmt_fabsd.f
1114 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1115 
  int UNUSED written = 0;
1116 
  IADDR UNUSED pc = abuf->addr;
1117 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1118 
 
1119 
  {
1120 
    SF opval = sh64_fcnvds (current_cpu, GET_H_DR (FLD (f_left_right)));
1121 
    CPU (h_fr[FLD (f_dest)]) = opval;
1122 
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1123 
  }
1124 
 
1125 
  return vpc;
1126 
#undef FLD
1127 
}
1128 
 
1129 
/* fcnvsd: fcnv.sd $frgh, $drf */
1130 
 
1131 
static SEM_PC
1132 
SEM_FN_NAME (sh64_media,fcnvsd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1133 
{
1134 
#define FLD(f) abuf->fields.sfmt_fabsd.f
1135 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1136 
  int UNUSED written = 0;
1137 
  IADDR UNUSED pc = abuf->addr;
1138 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1139 
 
1140 
  {
1141 
    DF opval = sh64_fcnvsd (current_cpu, CPU (h_fr[FLD (f_left_right)]));
1142 
    SET_H_DR (FLD (f_dest), opval);
1143 
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1144 
  }
1145 
 
1146 
  return vpc;
1147 
#undef FLD
1148 
}
1149 
 
1150 
/* fdivd: fdiv.d $drg, $drh, $drf */
1151 
 
1152 
static SEM_PC
1153 
SEM_FN_NAME (sh64_media,fdivd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1154 
{
1155 
#define FLD(f) abuf->fields.sfmt_add.f
1156 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1157 
  int UNUSED written = 0;
1158 
  IADDR UNUSED pc = abuf->addr;
1159 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1160 
 
1161 
  {
1162 
    DF opval = sh64_fdivd (current_cpu, GET_H_DR (FLD (f_left)), GET_H_DR (FLD (f_right)));
1163 
    SET_H_DR (FLD (f_dest), opval);
1164 
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1165 
  }
1166 
 
1167 
  return vpc;
1168 
#undef FLD
1169 
}
1170 
 
1171 
/* fdivs: fdiv.s $frg, $frh, $frf */
1172 
 
1173 
static SEM_PC
1174 
SEM_FN_NAME (sh64_media,fdivs) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1175 
{
1176 
#define FLD(f) abuf->fields.sfmt_add.f
1177 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1178 
  int UNUSED written = 0;
1179 
  IADDR UNUSED pc = abuf->addr;
1180 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1181 
 
1182 
  {
1183 
    SF opval = sh64_fdivs (current_cpu, CPU (h_fr[FLD (f_left)]), CPU (h_fr[FLD (f_right)]));
1184 
    CPU (h_fr[FLD (f_dest)]) = opval;
1185 
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1186 
  }
1187 
 
1188 
  return vpc;
1189 
#undef FLD
1190 
}
1191 
 
1192 
/* fgetscr: fgetscr $frf */
1193 
 
1194 
static SEM_PC
1195 
SEM_FN_NAME (sh64_media,fgetscr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1196 
{
1197 
#define FLD(f) abuf->fields.sfmt_shori.f
1198 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1199 
  int UNUSED written = 0;
1200 
  IADDR UNUSED pc = abuf->addr;
1201 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1202 
 
1203 
  {
1204 
    SF opval = SUBWORDSISF (CPU (h_fpscr));
1205 
    CPU (h_fr[FLD (f_dest)]) = opval;
1206 
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1207 
  }
1208 
 
1209 
  return vpc;
1210 
#undef FLD
1211 
}
1212 
 
1213 
/* fiprs: fipr.s $fvg, $fvh, $frf */
1214 
 
1215 
static SEM_PC
1216 
SEM_FN_NAME (sh64_media,fiprs) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1217 
{
1218 
#define FLD(f) abuf->fields.sfmt_add.f
1219 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1220 
  int UNUSED written = 0;
1221 
  IADDR UNUSED pc = abuf->addr;
1222 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1223 
 
1224 
{
1225 
  {
1226 
    SF opval = GET_H_FV (FLD (f_left));
1227 
    SET_H_FV (FLD (f_left), opval);
1228 
    TRACE_RESULT (current_cpu, abuf, "fv", 'f', opval);
1229 
  }
1230 
  {
1231 
    SF opval = GET_H_FV (FLD (f_right));
1232 
    SET_H_FV (FLD (f_right), opval);
1233 
    TRACE_RESULT (current_cpu, abuf, "fv", 'f', opval);
1234 
  }
1235 
  {
1236 
    SF opval = sh64_fiprs (current_cpu, FLD (f_left), FLD (f_right));
1237 
    CPU (h_fr[FLD (f_dest)]) = opval;
1238 
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1239 
  }
1240 
}
1241 
 
1242 
  return vpc;
1243 
#undef FLD
1244 
}
1245 
 
1246 
/* fldd: fld.d $rm, $disp10x8, $drf */
1247 
 
1248 
static SEM_PC
1249 
SEM_FN_NAME (sh64_media,fldd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1250 
{
1251 
#define FLD(f) abuf->fields.sfmt_fldd.f
1252 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1253 
  int UNUSED written = 0;
1254 
  IADDR UNUSED pc = abuf->addr;
1255 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1256 
 
1257 
  {
1258 
    DF opval = GETMEMDF (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp10x8)));
1259 
    SET_H_DR (FLD (f_dest), opval);
1260 
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1261 
  }
1262 
 
1263 
  return vpc;
1264 
#undef FLD
1265 
}
1266 
 
1267 
/* fldp: fld.p $rm, $disp10x8, $fpf */
1268 
 
1269 
static SEM_PC
1270 
SEM_FN_NAME (sh64_media,fldp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1271 
{
1272 
#define FLD(f) abuf->fields.sfmt_fldd.f
1273 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1274 
  int UNUSED written = 0;
1275 
  IADDR UNUSED pc = abuf->addr;
1276 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1277 
 
1278 
{
1279 
  {
1280 
    SF opval = GET_H_FP (FLD (f_dest));
1281 
    SET_H_FP (FLD (f_dest), opval);
1282 
    TRACE_RESULT (current_cpu, abuf, "fp", 'f', opval);
1283 
  }
1284 
sh64_fldp (current_cpu, pc, GET_H_GR (FLD (f_left)), FLD (f_disp10x8), FLD (f_dest));
1285 
}
1286 
 
1287 
  return vpc;
1288 
#undef FLD
1289 
}
1290 
 
1291 
/* flds: fld.s $rm, $disp10x4, $frf */
1292 
 
1293 
static SEM_PC
1294 
SEM_FN_NAME (sh64_media,flds) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1295 
{
1296 
#define FLD(f) abuf->fields.sfmt_flds.f
1297 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1298 
  int UNUSED written = 0;
1299 
  IADDR UNUSED pc = abuf->addr;
1300 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1301 
 
1302 
  {
1303 
    SF opval = GETMEMSF (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp10x4)));
1304 
    CPU (h_fr[FLD (f_dest)]) = opval;
1305 
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1306 
  }
1307 
 
1308 
  return vpc;
1309 
#undef FLD
1310 
}
1311 
 
1312 
/* fldxd: fldx.d $rm, $rn, $drf */
1313 
 
1314 
static SEM_PC
1315 
SEM_FN_NAME (sh64_media,fldxd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1316 
{
1317 
#define FLD(f) abuf->fields.sfmt_add.f
1318 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1319 
  int UNUSED written = 0;
1320 
  IADDR UNUSED pc = abuf->addr;
1321 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1322 
 
1323 
  {
1324 
    DF opval = GETMEMDF (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right))));
1325 
    SET_H_DR (FLD (f_dest), opval);
1326 
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1327 
  }
1328 
 
1329 
  return vpc;
1330 
#undef FLD
1331 
}
1332 
 
1333 
/* fldxp: fldx.p $rm, $rn, $fpf */
1334 
 
1335 
static SEM_PC
1336 
SEM_FN_NAME (sh64_media,fldxp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1337 
{
1338 
#define FLD(f) abuf->fields.sfmt_add.f
1339 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1340 
  int UNUSED written = 0;
1341 
  IADDR UNUSED pc = abuf->addr;
1342 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1343 
 
1344 
{
1345 
  {
1346 
    SF opval = GET_H_FP (FLD (f_dest));
1347 
    SET_H_FP (FLD (f_dest), opval);
1348 
    TRACE_RESULT (current_cpu, abuf, "fp", 'f', opval);
1349 
  }
1350 
sh64_fldp (current_cpu, pc, GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)), FLD (f_dest));
1351 
}
1352 
 
1353 
  return vpc;
1354 
#undef FLD
1355 
}
1356 
 
1357 
/* fldxs: fldx.s $rm, $rn, $frf */
1358 
 
1359 
static SEM_PC
1360 
SEM_FN_NAME (sh64_media,fldxs) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1361 
{
1362 
#define FLD(f) abuf->fields.sfmt_add.f
1363 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1364 
  int UNUSED written = 0;
1365 
  IADDR UNUSED pc = abuf->addr;
1366 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1367 
 
1368 
  {
1369 
    SF opval = GETMEMSF (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right))));
1370 
    CPU (h_fr[FLD (f_dest)]) = opval;
1371 
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1372 
  }
1373 
 
1374 
  return vpc;
1375 
#undef FLD
1376 
}
1377 
 
1378 
/* floatld: float.ld $frgh, $drf */
1379 
 
1380 
static SEM_PC
1381 
SEM_FN_NAME (sh64_media,floatld) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1382 
{
1383 
#define FLD(f) abuf->fields.sfmt_fabsd.f
1384 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1385 
  int UNUSED written = 0;
1386 
  IADDR UNUSED pc = abuf->addr;
1387 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1388 
 
1389 
  {
1390 
    DF opval = sh64_floatld (current_cpu, CPU (h_fr[FLD (f_left_right)]));
1391 
    SET_H_DR (FLD (f_dest), opval);
1392 
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1393 
  }
1394 
 
1395 
  return vpc;
1396 
#undef FLD
1397 
}
1398 
 
1399 
/* floatls: float.ls $frgh, $frf */
1400 
 
1401 
static SEM_PC
1402 
SEM_FN_NAME (sh64_media,floatls) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1403 
{
1404 
#define FLD(f) abuf->fields.sfmt_fabsd.f
1405 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1406 
  int UNUSED written = 0;
1407 
  IADDR UNUSED pc = abuf->addr;
1408 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1409 
 
1410 
  {
1411 
    SF opval = sh64_floatls (current_cpu, CPU (h_fr[FLD (f_left_right)]));
1412 
    CPU (h_fr[FLD (f_dest)]) = opval;
1413 
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1414 
  }
1415 
 
1416 
  return vpc;
1417 
#undef FLD
1418 
}
1419 
 
1420 
/* floatqd: float.qd $drgh, $drf */
1421 
 
1422 
static SEM_PC
1423 
SEM_FN_NAME (sh64_media,floatqd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1424 
{
1425 
#define FLD(f) abuf->fields.sfmt_fabsd.f
1426 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1427 
  int UNUSED written = 0;
1428 
  IADDR UNUSED pc = abuf->addr;
1429 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1430 
 
1431 
  {
1432 
    DF opval = sh64_floatqd (current_cpu, GET_H_DR (FLD (f_left_right)));
1433 
    SET_H_DR (FLD (f_dest), opval);
1434 
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1435 
  }
1436 
 
1437 
  return vpc;
1438 
#undef FLD
1439 
}
1440 
 
1441 
/* floatqs: float.qs $drgh, $frf */
1442 
 
1443 
static SEM_PC
1444 
SEM_FN_NAME (sh64_media,floatqs) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1445 
{
1446 
#define FLD(f) abuf->fields.sfmt_fabsd.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, 4);
1451 
 
1452 
  {
1453 
    SF opval = sh64_floatqs (current_cpu, GET_H_DR (FLD (f_left_right)));
1454 
    CPU (h_fr[FLD (f_dest)]) = opval;
1455 
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1456 
  }
1457 
 
1458 
  return vpc;
1459 
#undef FLD
1460 
}
1461 
 
1462 
/* fmacs: fmac.s $frg, $frh, $frf */
1463 
 
1464 
static SEM_PC
1465 
SEM_FN_NAME (sh64_media,fmacs) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1466 
{
1467 
#define FLD(f) abuf->fields.sfmt_add.f
1468 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1469 
  int UNUSED written = 0;
1470 
  IADDR UNUSED pc = abuf->addr;
1471 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1472 
 
1473 
  {
1474 
    SF opval = sh64_fadds (current_cpu, CPU (h_fr[FLD (f_dest)]), sh64_fmuls (current_cpu, CPU (h_fr[FLD (f_left)]), CPU (h_fr[FLD (f_right)])));
1475 
    CPU (h_fr[FLD (f_dest)]) = opval;
1476 
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1477 
  }
1478 
 
1479 
  return vpc;
1480 
#undef FLD
1481 
}
1482 
 
1483 
/* fmovd: fmov.d $drgh, $drf */
1484 
 
1485 
static SEM_PC
1486 
SEM_FN_NAME (sh64_media,fmovd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1487 
{
1488 
#define FLD(f) abuf->fields.sfmt_fabsd.f
1489 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1490 
  int UNUSED written = 0;
1491 
  IADDR UNUSED pc = abuf->addr;
1492 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1493 
 
1494 
  {
1495 
    DF opval = GET_H_DR (FLD (f_left_right));
1496 
    SET_H_DR (FLD (f_dest), opval);
1497 
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1498 
  }
1499 
 
1500 
  return vpc;
1501 
#undef FLD
1502 
}
1503 
 
1504 
/* fmovdq: fmov.dq $drgh, $rd */
1505 
 
1506 
static SEM_PC
1507 
SEM_FN_NAME (sh64_media,fmovdq) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1508 
{
1509 
#define FLD(f) abuf->fields.sfmt_fabsd.f
1510 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1511 
  int UNUSED written = 0;
1512 
  IADDR UNUSED pc = abuf->addr;
1513 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1514 
 
1515 
  {
1516 
    DI opval = SUBWORDDFDI (GET_H_DR (FLD (f_left_right)));
1517 
    SET_H_GR (FLD (f_dest), opval);
1518 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
1519 
  }
1520 
 
1521 
  return vpc;
1522 
#undef FLD
1523 
}
1524 
 
1525 
/* fmovls: fmov.ls $rm, $frf */
1526 
 
1527 
static SEM_PC
1528 
SEM_FN_NAME (sh64_media,fmovls) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1529 
{
1530 
#define FLD(f) abuf->fields.sfmt_xori.f
1531 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1532 
  int UNUSED written = 0;
1533 
  IADDR UNUSED pc = abuf->addr;
1534 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1535 
 
1536 
  {
1537 
    SF opval = SUBWORDSISF (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1));
1538 
    CPU (h_fr[FLD (f_dest)]) = opval;
1539 
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1540 
  }
1541 
 
1542 
  return vpc;
1543 
#undef FLD
1544 
}
1545 
 
1546 
/* fmovqd: fmov.qd $rm, $drf */
1547 
 
1548 
static SEM_PC
1549 
SEM_FN_NAME (sh64_media,fmovqd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1550 
{
1551 
#define FLD(f) abuf->fields.sfmt_xori.f
1552 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1553 
  int UNUSED written = 0;
1554 
  IADDR UNUSED pc = abuf->addr;
1555 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1556 
 
1557 
  {
1558 
    DF opval = SUBWORDDIDF (GET_H_GR (FLD (f_left)));
1559 
    SET_H_DR (FLD (f_dest), opval);
1560 
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1561 
  }
1562 
 
1563 
  return vpc;
1564 
#undef FLD
1565 
}
1566 
 
1567 
/* fmovs: fmov.s $frgh, $frf */
1568 
 
1569 
static SEM_PC
1570 
SEM_FN_NAME (sh64_media,fmovs) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1571 
{
1572 
#define FLD(f) abuf->fields.sfmt_fabsd.f
1573 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1574 
  int UNUSED written = 0;
1575 
  IADDR UNUSED pc = abuf->addr;
1576 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1577 
 
1578 
  {
1579 
    SF opval = CPU (h_fr[FLD (f_left_right)]);
1580 
    CPU (h_fr[FLD (f_dest)]) = opval;
1581 
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1582 
  }
1583 
 
1584 
  return vpc;
1585 
#undef FLD
1586 
}
1587 
 
1588 
/* fmovsl: fmov.sl $frgh, $rd */
1589 
 
1590 
static SEM_PC
1591 
SEM_FN_NAME (sh64_media,fmovsl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1592 
{
1593 
#define FLD(f) abuf->fields.sfmt_fabsd.f
1594 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1595 
  int UNUSED written = 0;
1596 
  IADDR UNUSED pc = abuf->addr;
1597 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1598 
 
1599 
  {
1600 
    DI opval = EXTSIDI (SUBWORDSFSI (CPU (h_fr[FLD (f_left_right)])));
1601 
    SET_H_GR (FLD (f_dest), opval);
1602 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
1603 
  }
1604 
 
1605 
  return vpc;
1606 
#undef FLD
1607 
}
1608 
 
1609 
/* fmuld: fmul.d $drg, $drh, $drf */
1610 
 
1611 
static SEM_PC
1612 
SEM_FN_NAME (sh64_media,fmuld) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1613 
{
1614 
#define FLD(f) abuf->fields.sfmt_add.f
1615 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1616 
  int UNUSED written = 0;
1617 
  IADDR UNUSED pc = abuf->addr;
1618 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1619 
 
1620 
  {
1621 
    DF opval = sh64_fmuld (current_cpu, GET_H_DR (FLD (f_left)), GET_H_DR (FLD (f_right)));
1622 
    SET_H_DR (FLD (f_dest), opval);
1623 
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1624 
  }
1625 
 
1626 
  return vpc;
1627 
#undef FLD
1628 
}
1629 
 
1630 
/* fmuls: fmul.s $frg, $frh, $frf */
1631 
 
1632 
static SEM_PC
1633 
SEM_FN_NAME (sh64_media,fmuls) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1634 
{
1635 
#define FLD(f) abuf->fields.sfmt_add.f
1636 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1637 
  int UNUSED written = 0;
1638 
  IADDR UNUSED pc = abuf->addr;
1639 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1640 
 
1641 
  {
1642 
    SF opval = sh64_fmuls (current_cpu, CPU (h_fr[FLD (f_left)]), CPU (h_fr[FLD (f_right)]));
1643 
    CPU (h_fr[FLD (f_dest)]) = opval;
1644 
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1645 
  }
1646 
 
1647 
  return vpc;
1648 
#undef FLD
1649 
}
1650 
 
1651 
/* fnegd: fneg.d $drgh, $drf */
1652 
 
1653 
static SEM_PC
1654 
SEM_FN_NAME (sh64_media,fnegd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1655 
{
1656 
#define FLD(f) abuf->fields.sfmt_fabsd.f
1657 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1658 
  int UNUSED written = 0;
1659 
  IADDR UNUSED pc = abuf->addr;
1660 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1661 
 
1662 
  {
1663 
    DF opval = sh64_fnegd (current_cpu, GET_H_DR (FLD (f_left_right)));
1664 
    SET_H_DR (FLD (f_dest), opval);
1665 
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1666 
  }
1667 
 
1668 
  return vpc;
1669 
#undef FLD
1670 
}
1671 
 
1672 
/* fnegs: fneg.s $frgh, $frf */
1673 
 
1674 
static SEM_PC
1675 
SEM_FN_NAME (sh64_media,fnegs) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1676 
{
1677 
#define FLD(f) abuf->fields.sfmt_fabsd.f
1678 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1679 
  int UNUSED written = 0;
1680 
  IADDR UNUSED pc = abuf->addr;
1681 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1682 
 
1683 
  {
1684 
    SF opval = sh64_fnegs (current_cpu, CPU (h_fr[FLD (f_left_right)]));
1685 
    CPU (h_fr[FLD (f_dest)]) = opval;
1686 
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1687 
  }
1688 
 
1689 
  return vpc;
1690 
#undef FLD
1691 
}
1692 
 
1693 
/* fputscr: fputscr $frgh */
1694 
 
1695 
static SEM_PC
1696 
SEM_FN_NAME (sh64_media,fputscr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1697 
{
1698 
#define FLD(f) abuf->fields.sfmt_fabsd.f
1699 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1700 
  int UNUSED written = 0;
1701 
  IADDR UNUSED pc = abuf->addr;
1702 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1703 
 
1704 
  {
1705 
    SI opval = SUBWORDSFSI (CPU (h_fr[FLD (f_left_right)]));
1706 
    CPU (h_fpscr) = opval;
1707 
    TRACE_RESULT (current_cpu, abuf, "fpscr", 'x', opval);
1708 
  }
1709 
 
1710 
  return vpc;
1711 
#undef FLD
1712 
}
1713 
 
1714 
/* fsqrtd: fsqrt.d $drgh, $drf */
1715 
 
1716 
static SEM_PC
1717 
SEM_FN_NAME (sh64_media,fsqrtd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1718 
{
1719 
#define FLD(f) abuf->fields.sfmt_fabsd.f
1720 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1721 
  int UNUSED written = 0;
1722 
  IADDR UNUSED pc = abuf->addr;
1723 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1724 
 
1725 
  {
1726 
    DF opval = sh64_fsqrtd (current_cpu, GET_H_DR (FLD (f_left_right)));
1727 
    SET_H_DR (FLD (f_dest), opval);
1728 
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1729 
  }
1730 
 
1731 
  return vpc;
1732 
#undef FLD
1733 
}
1734 
 
1735 
/* fsqrts: fsqrt.s $frgh, $frf */
1736 
 
1737 
static SEM_PC
1738 
SEM_FN_NAME (sh64_media,fsqrts) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1739 
{
1740 
#define FLD(f) abuf->fields.sfmt_fabsd.f
1741 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1742 
  int UNUSED written = 0;
1743 
  IADDR UNUSED pc = abuf->addr;
1744 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1745 
 
1746 
  {
1747 
    SF opval = sh64_fsqrts (current_cpu, CPU (h_fr[FLD (f_left_right)]));
1748 
    CPU (h_fr[FLD (f_dest)]) = opval;
1749 
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1750 
  }
1751 
 
1752 
  return vpc;
1753 
#undef FLD
1754 
}
1755 
 
1756 
/* fstd: fst.d $rm, $disp10x8, $drf */
1757 
 
1758 
static SEM_PC
1759 
SEM_FN_NAME (sh64_media,fstd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1760 
{
1761 
#define FLD(f) abuf->fields.sfmt_fldd.f
1762 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1763 
  int UNUSED written = 0;
1764 
  IADDR UNUSED pc = abuf->addr;
1765 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1766 
 
1767 
  {
1768 
    DF opval = GET_H_DR (FLD (f_dest));
1769 
    SETMEMDF (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp10x8)), opval);
1770 
    TRACE_RESULT (current_cpu, abuf, "memory", 'f', opval);
1771 
  }
1772 
 
1773 
  return vpc;
1774 
#undef FLD
1775 
}
1776 
 
1777 
/* fstp: fst.p $rm, $disp10x8, $fpf */
1778 
 
1779 
static SEM_PC
1780 
SEM_FN_NAME (sh64_media,fstp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1781 
{
1782 
#define FLD(f) abuf->fields.sfmt_fldd.f
1783 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1784 
  int UNUSED written = 0;
1785 
  IADDR UNUSED pc = abuf->addr;
1786 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1787 
 
1788 
{
1789 
  {
1790 
    SF opval = GET_H_FP (FLD (f_dest));
1791 
    SET_H_FP (FLD (f_dest), opval);
1792 
    TRACE_RESULT (current_cpu, abuf, "fp", 'f', opval);
1793 
  }
1794 
sh64_fstp (current_cpu, pc, GET_H_GR (FLD (f_left)), FLD (f_disp10x8), FLD (f_dest));
1795 
}
1796 
 
1797 
  return vpc;
1798 
#undef FLD
1799 
}
1800 
 
1801 
/* fsts: fst.s $rm, $disp10x4, $frf */
1802 
 
1803 
static SEM_PC
1804 
SEM_FN_NAME (sh64_media,fsts) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1805 
{
1806 
#define FLD(f) abuf->fields.sfmt_flds.f
1807 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1808 
  int UNUSED written = 0;
1809 
  IADDR UNUSED pc = abuf->addr;
1810 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1811 
 
1812 
  {
1813 
    SF opval = CPU (h_fr[FLD (f_dest)]);
1814 
    SETMEMSF (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp10x4)), opval);
1815 
    TRACE_RESULT (current_cpu, abuf, "memory", 'f', opval);
1816 
  }
1817 
 
1818 
  return vpc;
1819 
#undef FLD
1820 
}
1821 
 
1822 
/* fstxd: fstx.d $rm, $rn, $drf */
1823 
 
1824 
static SEM_PC
1825 
SEM_FN_NAME (sh64_media,fstxd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1826 
{
1827 
#define FLD(f) abuf->fields.sfmt_add.f
1828 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1829 
  int UNUSED written = 0;
1830 
  IADDR UNUSED pc = abuf->addr;
1831 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1832 
 
1833 
  {
1834 
    DF opval = GET_H_DR (FLD (f_dest));
1835 
    SETMEMDF (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right))), opval);
1836 
    TRACE_RESULT (current_cpu, abuf, "memory", 'f', opval);
1837 
  }
1838 
 
1839 
  return vpc;
1840 
#undef FLD
1841 
}
1842 
 
1843 
/* fstxp: fstx.p $rm, $rn, $fpf */
1844 
 
1845 
static SEM_PC
1846 
SEM_FN_NAME (sh64_media,fstxp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1847 
{
1848 
#define FLD(f) abuf->fields.sfmt_add.f
1849 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1850 
  int UNUSED written = 0;
1851 
  IADDR UNUSED pc = abuf->addr;
1852 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1853 
 
1854 
{
1855 
  {
1856 
    SF opval = GET_H_FP (FLD (f_dest));
1857 
    SET_H_FP (FLD (f_dest), opval);
1858 
    TRACE_RESULT (current_cpu, abuf, "fp", 'f', opval);
1859 
  }
1860 
sh64_fstp (current_cpu, pc, GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)), FLD (f_dest));
1861 
}
1862 
 
1863 
  return vpc;
1864 
#undef FLD
1865 
}
1866 
 
1867 
/* fstxs: fstx.s $rm, $rn, $frf */
1868 
 
1869 
static SEM_PC
1870 
SEM_FN_NAME (sh64_media,fstxs) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1871 
{
1872 
#define FLD(f) abuf->fields.sfmt_add.f
1873 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1874 
  int UNUSED written = 0;
1875 
  IADDR UNUSED pc = abuf->addr;
1876 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1877 
 
1878 
  {
1879 
    SF opval = CPU (h_fr[FLD (f_dest)]);
1880 
    SETMEMSF (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right))), opval);
1881 
    TRACE_RESULT (current_cpu, abuf, "memory", 'f', opval);
1882 
  }
1883 
 
1884 
  return vpc;
1885 
#undef FLD
1886 
}
1887 
 
1888 
/* fsubd: fsub.d $drg, $drh, $drf */
1889 
 
1890 
static SEM_PC
1891 
SEM_FN_NAME (sh64_media,fsubd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1892 
{
1893 
#define FLD(f) abuf->fields.sfmt_add.f
1894 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1895 
  int UNUSED written = 0;
1896 
  IADDR UNUSED pc = abuf->addr;
1897 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1898 
 
1899 
  {
1900 
    DF opval = sh64_fsubd (current_cpu, GET_H_DR (FLD (f_left)), GET_H_DR (FLD (f_right)));
1901 
    SET_H_DR (FLD (f_dest), opval);
1902 
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1903 
  }
1904 
 
1905 
  return vpc;
1906 
#undef FLD
1907 
}
1908 
 
1909 
/* fsubs: fsub.s $frg, $frh, $frf */
1910 
 
1911 
static SEM_PC
1912 
SEM_FN_NAME (sh64_media,fsubs) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1913 
{
1914 
#define FLD(f) abuf->fields.sfmt_add.f
1915 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1916 
  int UNUSED written = 0;
1917 
  IADDR UNUSED pc = abuf->addr;
1918 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1919 
 
1920 
  {
1921 
    SF opval = sh64_fsubs (current_cpu, CPU (h_fr[FLD (f_left)]), CPU (h_fr[FLD (f_right)]));
1922 
    CPU (h_fr[FLD (f_dest)]) = opval;
1923 
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1924 
  }
1925 
 
1926 
  return vpc;
1927 
#undef FLD
1928 
}
1929 
 
1930 
/* ftrcdl: ftrc.dl $drgh, $frf */
1931 
 
1932 
static SEM_PC
1933 
SEM_FN_NAME (sh64_media,ftrcdl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1934 
{
1935 
#define FLD(f) abuf->fields.sfmt_fabsd.f
1936 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1937 
  int UNUSED written = 0;
1938 
  IADDR UNUSED pc = abuf->addr;
1939 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1940 
 
1941 
  {
1942 
    SF opval = sh64_ftrcdl (current_cpu, GET_H_DR (FLD (f_left_right)));
1943 
    CPU (h_fr[FLD (f_dest)]) = opval;
1944 
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1945 
  }
1946 
 
1947 
  return vpc;
1948 
#undef FLD
1949 
}
1950 
 
1951 
/* ftrcsl: ftrc.sl $frgh, $frf */
1952 
 
1953 
static SEM_PC
1954 
SEM_FN_NAME (sh64_media,ftrcsl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1955 
{
1956 
#define FLD(f) abuf->fields.sfmt_fabsd.f
1957 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1958 
  int UNUSED written = 0;
1959 
  IADDR UNUSED pc = abuf->addr;
1960 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1961 
 
1962 
  {
1963 
    SF opval = sh64_ftrcsl (current_cpu, CPU (h_fr[FLD (f_left_right)]));
1964 
    CPU (h_fr[FLD (f_dest)]) = opval;
1965 
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1966 
  }
1967 
 
1968 
  return vpc;
1969 
#undef FLD
1970 
}
1971 
 
1972 
/* ftrcdq: ftrc.dq $drgh, $drf */
1973 
 
1974 
static SEM_PC
1975 
SEM_FN_NAME (sh64_media,ftrcdq) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1976 
{
1977 
#define FLD(f) abuf->fields.sfmt_fabsd.f
1978 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1979 
  int UNUSED written = 0;
1980 
  IADDR UNUSED pc = abuf->addr;
1981 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1982 
 
1983 
  {
1984 
    DF opval = sh64_ftrcdq (current_cpu, GET_H_DR (FLD (f_left_right)));
1985 
    SET_H_DR (FLD (f_dest), opval);
1986 
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1987 
  }
1988 
 
1989 
  return vpc;
1990 
#undef FLD
1991 
}
1992 
 
1993 
/* ftrcsq: ftrc.sq $frgh, $drf */
1994 
 
1995 
static SEM_PC
1996 
SEM_FN_NAME (sh64_media,ftrcsq) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1997 
{
1998 
#define FLD(f) abuf->fields.sfmt_fabsd.f
1999 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2000 
  int UNUSED written = 0;
2001 
  IADDR UNUSED pc = abuf->addr;
2002 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2003 
 
2004 
  {
2005 
    DF opval = sh64_ftrcsq (current_cpu, CPU (h_fr[FLD (f_left_right)]));
2006 
    SET_H_DR (FLD (f_dest), opval);
2007 
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
2008 
  }
2009 
 
2010 
  return vpc;
2011 
#undef FLD
2012 
}
2013 
 
2014 
/* ftrvs: ftrv.s $mtrxg, $fvh, $fvf */
2015 
 
2016 
static SEM_PC
2017 
SEM_FN_NAME (sh64_media,ftrvs) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2018 
{
2019 
#define FLD(f) abuf->fields.sfmt_add.f
2020 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2021 
  int UNUSED written = 0;
2022 
  IADDR UNUSED pc = abuf->addr;
2023 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2024 
 
2025 
{
2026 
  {
2027 
    SF opval = GET_H_FMTX (FLD (f_left));
2028 
    SET_H_FMTX (FLD (f_left), opval);
2029 
    TRACE_RESULT (current_cpu, abuf, "fmtx", 'f', opval);
2030 
  }
2031 
  {
2032 
    SF opval = GET_H_FV (FLD (f_right));
2033 
    SET_H_FV (FLD (f_right), opval);
2034 
    TRACE_RESULT (current_cpu, abuf, "fv", 'f', opval);
2035 
  }
2036 
  {
2037 
    SF opval = GET_H_FV (FLD (f_dest));
2038 
    SET_H_FV (FLD (f_dest), opval);
2039 
    TRACE_RESULT (current_cpu, abuf, "fv", 'f', opval);
2040 
  }
2041 
sh64_ftrvs (current_cpu, FLD (f_left), FLD (f_right), FLD (f_dest));
2042 
}
2043 
 
2044 
  return vpc;
2045 
#undef FLD
2046 
}
2047 
 
2048 
/* getcfg: getcfg $rm, $disp6, $rd */
2049 
 
2050 
static SEM_PC
2051 
SEM_FN_NAME (sh64_media,getcfg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2052 
{
2053 
#define FLD(f) abuf->fields.sfmt_getcfg.f
2054 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2055 
  int UNUSED written = 0;
2056 
  IADDR UNUSED pc = abuf->addr;
2057 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2058 
 
2059 
{
2060 
  SI tmp_address;
2061 
  tmp_address = ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp6));
2062 
((void) 0); /*nop*/
2063 
  {
2064 
    DI opval = GETMEMSI (current_cpu, pc, tmp_address);
2065 
    SET_H_GR (FLD (f_dest), opval);
2066 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2067 
  }
2068 
}
2069 
 
2070 
  return vpc;
2071 
#undef FLD
2072 
}
2073 
 
2074 
/* getcon: getcon $crk, $rd */
2075 
 
2076 
static SEM_PC
2077 
SEM_FN_NAME (sh64_media,getcon) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2078 
{
2079 
#define FLD(f) abuf->fields.sfmt_xori.f
2080 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2081 
  int UNUSED written = 0;
2082 
  IADDR UNUSED pc = abuf->addr;
2083 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2084 
 
2085 
  {
2086 
    DI opval = GET_H_CR (FLD (f_left));
2087 
    SET_H_GR (FLD (f_dest), opval);
2088 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2089 
  }
2090 
 
2091 
  return vpc;
2092 
#undef FLD
2093 
}
2094 
 
2095 
/* gettr: gettr $trb, $rd */
2096 
 
2097 
static SEM_PC
2098 
SEM_FN_NAME (sh64_media,gettr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2099 
{
2100 
#define FLD(f) abuf->fields.sfmt_blink.f
2101 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2102 
  int UNUSED written = 0;
2103 
  IADDR UNUSED pc = abuf->addr;
2104 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2105 
 
2106 
  {
2107 
    DI opval = CPU (h_tr[FLD (f_trb)]);
2108 
    SET_H_GR (FLD (f_dest), opval);
2109 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2110 
  }
2111 
 
2112 
  return vpc;
2113 
#undef FLD
2114 
}
2115 
 
2116 
/* icbi: icbi $rm, $disp6x32 */
2117 
 
2118 
static SEM_PC
2119 
SEM_FN_NAME (sh64_media,icbi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2120 
{
2121 
#define FLD(f) abuf->fields.sfmt_xori.f
2122 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2123 
  int UNUSED written = 0;
2124 
  IADDR UNUSED pc = abuf->addr;
2125 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2126 
 
2127 
{
2128 
  {
2129 
    DI opval = GET_H_GR (FLD (f_left));
2130 
    SET_H_GR (FLD (f_left), opval);
2131 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2132 
  }
2133 
((void) 0); /*nop*/
2134 
}
2135 
 
2136 
  return vpc;
2137 
#undef FLD
2138 
}
2139 
 
2140 
/* ldb: ld.b $rm, $disp10, $rd */
2141 
 
2142 
static SEM_PC
2143 
SEM_FN_NAME (sh64_media,ldb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2144 
{
2145 
#define FLD(f) abuf->fields.sfmt_addi.f
2146 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2147 
  int UNUSED written = 0;
2148 
  IADDR UNUSED pc = abuf->addr;
2149 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2150 
 
2151 
  {
2152 
    DI opval = EXTQIDI (GETMEMQI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_disp10)))));
2153 
    SET_H_GR (FLD (f_dest), opval);
2154 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2155 
  }
2156 
 
2157 
  return vpc;
2158 
#undef FLD
2159 
}
2160 
 
2161 
/* ldl: ld.l $rm, $disp10x4, $rd */
2162 
 
2163 
static SEM_PC
2164 
SEM_FN_NAME (sh64_media,ldl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2165 
{
2166 
#define FLD(f) abuf->fields.sfmt_flds.f
2167 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2168 
  int UNUSED written = 0;
2169 
  IADDR UNUSED pc = abuf->addr;
2170 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2171 
 
2172 
  {
2173 
    DI opval = EXTSIDI (GETMEMSI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_disp10x4)))));
2174 
    SET_H_GR (FLD (f_dest), opval);
2175 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2176 
  }
2177 
 
2178 
  return vpc;
2179 
#undef FLD
2180 
}
2181 
 
2182 
/* ldq: ld.q $rm, $disp10x8, $rd */
2183 
 
2184 
static SEM_PC
2185 
SEM_FN_NAME (sh64_media,ldq) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2186 
{
2187 
#define FLD(f) abuf->fields.sfmt_fldd.f
2188 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2189 
  int UNUSED written = 0;
2190 
  IADDR UNUSED pc = abuf->addr;
2191 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2192 
 
2193 
  {
2194 
    DI opval = GETMEMDI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_disp10x8))));
2195 
    SET_H_GR (FLD (f_dest), opval);
2196 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2197 
  }
2198 
 
2199 
  return vpc;
2200 
#undef FLD
2201 
}
2202 
 
2203 
/* ldub: ld.ub $rm, $disp10, $rd */
2204 
 
2205 
static SEM_PC
2206 
SEM_FN_NAME (sh64_media,ldub) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2207 
{
2208 
#define FLD(f) abuf->fields.sfmt_addi.f
2209 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2210 
  int UNUSED written = 0;
2211 
  IADDR UNUSED pc = abuf->addr;
2212 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2213 
 
2214 
  {
2215 
    DI opval = ZEXTQIDI (GETMEMQI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_disp10)))));
2216 
    SET_H_GR (FLD (f_dest), opval);
2217 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2218 
  }
2219 
 
2220 
  return vpc;
2221 
#undef FLD
2222 
}
2223 
 
2224 
/* lduw: ld.uw $rm, $disp10x2, $rd */
2225 
 
2226 
static SEM_PC
2227 
SEM_FN_NAME (sh64_media,lduw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2228 
{
2229 
#define FLD(f) abuf->fields.sfmt_lduw.f
2230 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2231 
  int UNUSED written = 0;
2232 
  IADDR UNUSED pc = abuf->addr;
2233 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2234 
 
2235 
  {
2236 
    DI opval = ZEXTHIDI (GETMEMHI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_disp10x2)))));
2237 
    SET_H_GR (FLD (f_dest), opval);
2238 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2239 
  }
2240 
 
2241 
  return vpc;
2242 
#undef FLD
2243 
}
2244 
 
2245 
/* ldw: ld.w $rm, $disp10x2, $rd */
2246 
 
2247 
static SEM_PC
2248 
SEM_FN_NAME (sh64_media,ldw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2249 
{
2250 
#define FLD(f) abuf->fields.sfmt_lduw.f
2251 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2252 
  int UNUSED written = 0;
2253 
  IADDR UNUSED pc = abuf->addr;
2254 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2255 
 
2256 
  {
2257 
    DI opval = EXTHIDI (GETMEMHI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_disp10x2)))));
2258 
    SET_H_GR (FLD (f_dest), opval);
2259 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2260 
  }
2261 
 
2262 
  return vpc;
2263 
#undef FLD
2264 
}
2265 
 
2266 
/* ldhil: ldhi.l $rm, $disp6, $rd */
2267 
 
2268 
static SEM_PC
2269 
SEM_FN_NAME (sh64_media,ldhil) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2270 
{
2271 
#define FLD(f) abuf->fields.sfmt_getcfg.f
2272 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2273 
  int UNUSED written = 0;
2274 
  IADDR UNUSED pc = abuf->addr;
2275 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2276 
 
2277 
{
2278 
  DI tmp_addr;
2279 
  QI tmp_bytecount;
2280 
  SI tmp_val;
2281 
  tmp_addr = ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp6));
2282 
  tmp_bytecount = ADDDI (ANDDI (tmp_addr, 3), 1);
2283 
  tmp_val = 0;
2284 
if (ANDQI (tmp_bytecount, 4)) {
2285 
  {
2286 
    DI opval = EXTSIDI (GETMEMSI (current_cpu, pc, ANDDI (tmp_addr, -4)));
2287 
    SET_H_GR (FLD (f_dest), opval);
2288 
    written |= (1 << 6);
2289 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2290 
  }
2291 
} else {
2292 
if (GET_H_ENDIAN ()) {
2293 
{
2294 
if (ANDQI (tmp_bytecount, 2)) {
2295 
  tmp_val = ADDSI (SLLSI (tmp_val, 16), ZEXTHIDI (GETMEMHI (current_cpu, pc, ANDDI (tmp_addr, -4))));
2296 
}
2297 
if (ANDQI (tmp_bytecount, 1)) {
2298 
  tmp_val = ADDSI (SLLSI (tmp_val, 8), ZEXTQIDI (GETMEMQI (current_cpu, pc, tmp_addr)));
2299 
}
2300 
  {
2301 
    DI opval = EXTSIDI (tmp_val);
2302 
    SET_H_GR (FLD (f_dest), opval);
2303 
    written |= (1 << 6);
2304 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2305 
  }
2306 
}
2307 
} else {
2308 
{
2309 
if (ANDQI (tmp_bytecount, 1)) {
2310 
  tmp_val = ADDSI (SLLSI (tmp_val, 8), ZEXTQIDI (GETMEMQI (current_cpu, pc, tmp_addr)));
2311 
}
2312 
if (ANDQI (tmp_bytecount, 2)) {
2313 
  tmp_val = ADDSI (SLLSI (tmp_val, 16), ZEXTHIDI (GETMEMHI (current_cpu, pc, ANDDI (tmp_addr, -4))));
2314 
}
2315 
  {
2316 
    DI opval = EXTSIDI (SLLSI (tmp_val, SUBSI (32, MULSI (8, tmp_bytecount))));
2317 
    SET_H_GR (FLD (f_dest), opval);
2318 
    written |= (1 << 6);
2319 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2320 
  }
2321 
}
2322 
}
2323 
}
2324 
}
2325 
 
2326 
  abuf->written = written;
2327 
  return vpc;
2328 
#undef FLD
2329 
}
2330 
 
2331 
/* ldhiq: ldhi.q $rm, $disp6, $rd */
2332 
 
2333 
static SEM_PC
2334 
SEM_FN_NAME (sh64_media,ldhiq) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2335 
{
2336 
#define FLD(f) abuf->fields.sfmt_getcfg.f
2337 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2338 
  int UNUSED written = 0;
2339 
  IADDR UNUSED pc = abuf->addr;
2340 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2341 
 
2342 
{
2343 
  DI tmp_addr;
2344 
  QI tmp_bytecount;
2345 
  DI tmp_val;
2346 
  tmp_addr = ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp6));
2347 
  tmp_bytecount = ADDDI (ANDDI (tmp_addr, 7), 1);
2348 
  tmp_val = 0;
2349 
if (ANDQI (tmp_bytecount, 8)) {
2350 
  {
2351 
    DI opval = GETMEMDI (current_cpu, pc, ANDDI (tmp_addr, -8));
2352 
    SET_H_GR (FLD (f_dest), opval);
2353 
    written |= (1 << 7);
2354 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2355 
  }
2356 
} else {
2357 
if (GET_H_ENDIAN ()) {
2358 
{
2359 
if (ANDQI (tmp_bytecount, 4)) {
2360 
  tmp_val = ADDDI (SLLDI (tmp_val, 32), ZEXTSIDI (GETMEMSI (current_cpu, pc, ANDDI (tmp_addr, -8))));
2361 
}
2362 
if (ANDQI (tmp_bytecount, 2)) {
2363 
  tmp_val = ADDDI (SLLDI (tmp_val, 16), ZEXTHIDI (GETMEMHI (current_cpu, pc, ANDDI (tmp_addr, -4))));
2364 
}
2365 
if (ANDQI (tmp_bytecount, 1)) {
2366 
  tmp_val = ADDDI (SLLDI (tmp_val, 8), ZEXTQIDI (GETMEMQI (current_cpu, pc, tmp_addr)));
2367 
}
2368 
  {
2369 
    DI opval = tmp_val;
2370 
    SET_H_GR (FLD (f_dest), opval);
2371 
    written |= (1 << 7);
2372 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2373 
  }
2374 
}
2375 
} else {
2376 
{
2377 
if (ANDQI (tmp_bytecount, 1)) {
2378 
  tmp_val = ADDDI (SLLDI (tmp_val, 8), ZEXTQIDI (GETMEMQI (current_cpu, pc, tmp_addr)));
2379 
}
2380 
if (ANDQI (tmp_bytecount, 2)) {
2381 
  tmp_val = ADDDI (SLLDI (tmp_val, 16), ZEXTHIDI (GETMEMHI (current_cpu, pc, ANDDI (tmp_addr, -4))));
2382 
}
2383 
if (ANDQI (tmp_bytecount, 4)) {
2384 
  tmp_val = ADDDI (SLLDI (tmp_val, 32), ZEXTSIDI (GETMEMSI (current_cpu, pc, ANDDI (tmp_addr, -8))));
2385 
}
2386 
  {
2387 
    DI opval = SLLDI (tmp_val, SUBSI (64, MULSI (8, tmp_bytecount)));
2388 
    SET_H_GR (FLD (f_dest), opval);
2389 
    written |= (1 << 7);
2390 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2391 
  }
2392 
}
2393 
}
2394 
}
2395 
}
2396 
 
2397 
  abuf->written = written;
2398 
  return vpc;
2399 
#undef FLD
2400 
}
2401 
 
2402 
/* ldlol: ldlo.l $rm, $disp6, $rd */
2403 
 
2404 
static SEM_PC
2405 
SEM_FN_NAME (sh64_media,ldlol) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2406 
{
2407 
#define FLD(f) abuf->fields.sfmt_getcfg.f
2408 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2409 
  int UNUSED written = 0;
2410 
  IADDR UNUSED pc = abuf->addr;
2411 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2412 
 
2413 
{
2414 
  DI tmp_addr;
2415 
  QI tmp_bytecount;
2416 
  SI tmp_val;
2417 
  tmp_addr = ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp6));
2418 
  tmp_bytecount = SUBSI (4, ANDDI (tmp_addr, 3));
2419 
  tmp_val = 0;
2420 
if (ANDQI (tmp_bytecount, 4)) {
2421 
  {
2422 
    DI opval = EXTSIDI (GETMEMSI (current_cpu, pc, tmp_addr));
2423 
    SET_H_GR (FLD (f_dest), opval);
2424 
    written |= (1 << 6);
2425 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2426 
  }
2427 
} else {
2428 
if (GET_H_ENDIAN ()) {
2429 
{
2430 
if (ANDQI (tmp_bytecount, 1)) {
2431 
  tmp_val = ADDSI (SLLSI (tmp_val, 8), ZEXTQIDI (GETMEMQI (current_cpu, pc, tmp_addr)));
2432 
}
2433 
if (ANDQI (tmp_bytecount, 2)) {
2434 
  tmp_val = ADDSI (SLLSI (tmp_val, 16), ZEXTHIDI (GETMEMHI (current_cpu, pc, ANDDI (ADDDI (tmp_addr, 1), -2))));
2435 
}
2436 
  {
2437 
    DI opval = EXTSIDI (SLLSI (tmp_val, SUBSI (32, MULSI (8, tmp_bytecount))));
2438 
    SET_H_GR (FLD (f_dest), opval);
2439 
    written |= (1 << 6);
2440 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2441 
  }
2442 
}
2443 
} else {
2444 
{
2445 
if (ANDQI (tmp_bytecount, 2)) {
2446 
  tmp_val = ADDSI (SLLSI (tmp_val, 16), ZEXTHIDI (GETMEMHI (current_cpu, pc, ANDDI (ADDDI (tmp_addr, 1), -2))));
2447 
}
2448 
if (ANDQI (tmp_bytecount, 1)) {
2449 
  tmp_val = ADDSI (SLLSI (tmp_val, 8), ZEXTQIDI (GETMEMQI (current_cpu, pc, tmp_addr)));
2450 
}
2451 
  {
2452 
    DI opval = EXTSIDI (tmp_val);
2453 
    SET_H_GR (FLD (f_dest), opval);
2454 
    written |= (1 << 6);
2455 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2456 
  }
2457 
}
2458 
}
2459 
}
2460 
}
2461 
 
2462 
  abuf->written = written;
2463 
  return vpc;
2464 
#undef FLD
2465 
}
2466 
 
2467 
/* ldloq: ldlo.q $rm, $disp6, $rd */
2468 
 
2469 
static SEM_PC
2470 
SEM_FN_NAME (sh64_media,ldloq) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2471 
{
2472 
#define FLD(f) abuf->fields.sfmt_getcfg.f
2473 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2474 
  int UNUSED written = 0;
2475 
  IADDR UNUSED pc = abuf->addr;
2476 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2477 
 
2478 
{
2479 
  DI tmp_addr;
2480 
  QI tmp_bytecount;
2481 
  DI tmp_val;
2482 
  tmp_addr = ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp6));
2483 
  tmp_bytecount = SUBSI (8, ANDDI (tmp_addr, 7));
2484 
  tmp_val = 0;
2485 
if (ANDQI (tmp_bytecount, 8)) {
2486 
  {
2487 
    DI opval = GETMEMDI (current_cpu, pc, tmp_addr);
2488 
    SET_H_GR (FLD (f_dest), opval);
2489 
    written |= (1 << 7);
2490 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2491 
  }
2492 
} else {
2493 
if (GET_H_ENDIAN ()) {
2494 
{
2495 
if (ANDQI (tmp_bytecount, 1)) {
2496 
  tmp_val = ADDDI (SLLDI (tmp_val, 8), ZEXTQIDI (GETMEMQI (current_cpu, pc, tmp_addr)));
2497 
}
2498 
if (ANDQI (tmp_bytecount, 2)) {
2499 
  tmp_val = ADDDI (SLLDI (tmp_val, 16), ZEXTHIDI (GETMEMHI (current_cpu, pc, ANDDI (ADDDI (tmp_addr, 1), -2))));
2500 
}
2501 
if (ANDQI (tmp_bytecount, 4)) {
2502 
  tmp_val = ADDDI (SLLDI (tmp_val, 32), ZEXTSIDI (GETMEMSI (current_cpu, pc, ANDDI (ADDDI (tmp_addr, 3), -4))));
2503 
}
2504 
  {
2505 
    DI opval = SLLDI (tmp_val, SUBSI (64, MULSI (8, tmp_bytecount)));
2506 
    SET_H_GR (FLD (f_dest), opval);
2507 
    written |= (1 << 7);
2508 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2509 
  }
2510 
}
2511 
} else {
2512 
{
2513 
if (ANDQI (tmp_bytecount, 4)) {
2514 
  tmp_val = ADDDI (SLLDI (tmp_val, 32), ZEXTSIDI (GETMEMSI (current_cpu, pc, ANDDI (ADDDI (tmp_addr, 3), -4))));
2515 
}
2516 
if (ANDQI (tmp_bytecount, 2)) {
2517 
  tmp_val = ADDDI (SLLDI (tmp_val, 16), ZEXTHIDI (GETMEMHI (current_cpu, pc, ANDDI (ADDDI (tmp_addr, 1), -2))));
2518 
}
2519 
if (ANDQI (tmp_bytecount, 1)) {
2520 
  tmp_val = ADDDI (SLLDI (tmp_val, 8), ZEXTQIDI (GETMEMQI (current_cpu, pc, tmp_addr)));
2521 
}
2522 
  {
2523 
    DI opval = tmp_val;
2524 
    SET_H_GR (FLD (f_dest), opval);
2525 
    written |= (1 << 7);
2526 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2527 
  }
2528 
}
2529 
}
2530 
}
2531 
}
2532 
 
2533 
  abuf->written = written;
2534 
  return vpc;
2535 
#undef FLD
2536 
}
2537 
 
2538 
/* ldxb: ldx.b $rm, $rn, $rd */
2539 
 
2540 
static SEM_PC
2541 
SEM_FN_NAME (sh64_media,ldxb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2542 
{
2543 
#define FLD(f) abuf->fields.sfmt_add.f
2544 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2545 
  int UNUSED written = 0;
2546 
  IADDR UNUSED pc = abuf->addr;
2547 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2548 
 
2549 
  {
2550 
    DI opval = EXTQIDI (GETMEMQI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))));
2551 
    SET_H_GR (FLD (f_dest), opval);
2552 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2553 
  }
2554 
 
2555 
  return vpc;
2556 
#undef FLD
2557 
}
2558 
 
2559 
/* ldxl: ldx.l $rm, $rn, $rd */
2560 
 
2561 
static SEM_PC
2562 
SEM_FN_NAME (sh64_media,ldxl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2563 
{
2564 
#define FLD(f) abuf->fields.sfmt_add.f
2565 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2566 
  int UNUSED written = 0;
2567 
  IADDR UNUSED pc = abuf->addr;
2568 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2569 
 
2570 
  {
2571 
    DI opval = EXTSIDI (GETMEMSI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))));
2572 
    SET_H_GR (FLD (f_dest), opval);
2573 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2574 
  }
2575 
 
2576 
  return vpc;
2577 
#undef FLD
2578 
}
2579 
 
2580 
/* ldxq: ldx.q $rm, $rn, $rd */
2581 
 
2582 
static SEM_PC
2583 
SEM_FN_NAME (sh64_media,ldxq) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2584 
{
2585 
#define FLD(f) abuf->fields.sfmt_add.f
2586 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2587 
  int UNUSED written = 0;
2588 
  IADDR UNUSED pc = abuf->addr;
2589 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2590 
 
2591 
  {
2592 
    DI opval = GETMEMDI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right))));
2593 
    SET_H_GR (FLD (f_dest), opval);
2594 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2595 
  }
2596 
 
2597 
  return vpc;
2598 
#undef FLD
2599 
}
2600 
 
2601 
/* ldxub: ldx.ub $rm, $rn, $rd */
2602 
 
2603 
static SEM_PC
2604 
SEM_FN_NAME (sh64_media,ldxub) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2605 
{
2606 
#define FLD(f) abuf->fields.sfmt_add.f
2607 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2608 
  int UNUSED written = 0;
2609 
  IADDR UNUSED pc = abuf->addr;
2610 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2611 
 
2612 
  {
2613 
    DI opval = ZEXTQIDI (GETMEMUQI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))));
2614 
    SET_H_GR (FLD (f_dest), opval);
2615 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2616 
  }
2617 
 
2618 
  return vpc;
2619 
#undef FLD
2620 
}
2621 
 
2622 
/* ldxuw: ldx.uw $rm, $rn, $rd */
2623 
 
2624 
static SEM_PC
2625 
SEM_FN_NAME (sh64_media,ldxuw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2626 
{
2627 
#define FLD(f) abuf->fields.sfmt_add.f
2628 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2629 
  int UNUSED written = 0;
2630 
  IADDR UNUSED pc = abuf->addr;
2631 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2632 
 
2633 
  {
2634 
    DI opval = ZEXTHIDI (GETMEMUHI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))));
2635 
    SET_H_GR (FLD (f_dest), opval);
2636 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2637 
  }
2638 
 
2639 
  return vpc;
2640 
#undef FLD
2641 
}
2642 
 
2643 
/* ldxw: ldx.w $rm, $rn, $rd */
2644 
 
2645 
static SEM_PC
2646 
SEM_FN_NAME (sh64_media,ldxw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2647 
{
2648 
#define FLD(f) abuf->fields.sfmt_add.f
2649 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2650 
  int UNUSED written = 0;
2651 
  IADDR UNUSED pc = abuf->addr;
2652 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2653 
 
2654 
  {
2655 
    DI opval = EXTHIDI (GETMEMHI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))));
2656 
    SET_H_GR (FLD (f_dest), opval);
2657 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2658 
  }
2659 
 
2660 
  return vpc;
2661 
#undef FLD
2662 
}
2663 
 
2664 
/* mabsl: mabs.l $rm, $rd */
2665 
 
2666 
static SEM_PC
2667 
SEM_FN_NAME (sh64_media,mabsl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2668 
{
2669 
#define FLD(f) abuf->fields.sfmt_xori.f
2670 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2671 
  int UNUSED written = 0;
2672 
  IADDR UNUSED pc = abuf->addr;
2673 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2674 
 
2675 
{
2676 
  SI tmp_result1;
2677 
  SI tmp_result0;
2678 
  tmp_result0 = ABSSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1));
2679 
  tmp_result1 = ABSSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0));
2680 
  {
2681 
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
2682 
    SET_H_GR (FLD (f_dest), opval);
2683 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2684 
  }
2685 
}
2686 
 
2687 
  return vpc;
2688 
#undef FLD
2689 
}
2690 
 
2691 
/* mabsw: mabs.w $rm, $rd */
2692 
 
2693 
static SEM_PC
2694 
SEM_FN_NAME (sh64_media,mabsw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2695 
{
2696 
#define FLD(f) abuf->fields.sfmt_xori.f
2697 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2698 
  int UNUSED written = 0;
2699 
  IADDR UNUSED pc = abuf->addr;
2700 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2701 
 
2702 
{
2703 
  HI tmp_result3;
2704 
  HI tmp_result2;
2705 
  HI tmp_result1;
2706 
  HI tmp_result0;
2707 
  tmp_result0 = ABSHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3));
2708 
  tmp_result1 = ABSHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2));
2709 
  tmp_result2 = ABSHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1));
2710 
  tmp_result3 = ABSHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0));
2711 
  {
2712 
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
2713 
    SET_H_GR (FLD (f_dest), opval);
2714 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2715 
  }
2716 
}
2717 
 
2718 
  return vpc;
2719 
#undef FLD
2720 
}
2721 
 
2722 
/* maddl: madd.l $rm, $rn, $rd */
2723 
 
2724 
static SEM_PC
2725 
SEM_FN_NAME (sh64_media,maddl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2726 
{
2727 
#define FLD(f) abuf->fields.sfmt_add.f
2728 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2729 
  int UNUSED written = 0;
2730 
  IADDR UNUSED pc = abuf->addr;
2731 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2732 
 
2733 
{
2734 
  SI tmp_result1;
2735 
  SI tmp_result0;
2736 
  tmp_result0 = ADDSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), SUBWORDDISI (GET_H_GR (FLD (f_right)), 1));
2737 
  tmp_result1 = ADDSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), SUBWORDDISI (GET_H_GR (FLD (f_right)), 0));
2738 
  {
2739 
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
2740 
    SET_H_GR (FLD (f_dest), opval);
2741 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2742 
  }
2743 
}
2744 
 
2745 
  return vpc;
2746 
#undef FLD
2747 
}
2748 
 
2749 
/* maddw: madd.w $rm, $rn, $rd */
2750 
 
2751 
static SEM_PC
2752 
SEM_FN_NAME (sh64_media,maddw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2753 
{
2754 
#define FLD(f) abuf->fields.sfmt_add.f
2755 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2756 
  int UNUSED written = 0;
2757 
  IADDR UNUSED pc = abuf->addr;
2758 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2759 
 
2760 
{
2761 
  HI tmp_result3;
2762 
  HI tmp_result2;
2763 
  HI tmp_result1;
2764 
  HI tmp_result0;
2765 
  tmp_result0 = ADDHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3));
2766 
  tmp_result1 = ADDHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2));
2767 
  tmp_result2 = ADDHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1));
2768 
  tmp_result3 = ADDHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0));
2769 
  {
2770 
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
2771 
    SET_H_GR (FLD (f_dest), opval);
2772 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2773 
  }
2774 
}
2775 
 
2776 
  return vpc;
2777 
#undef FLD
2778 
}
2779 
 
2780 
/* maddsl: madds.l $rm, $rn, $rd */
2781 
 
2782 
static SEM_PC
2783 
SEM_FN_NAME (sh64_media,maddsl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2784 
{
2785 
#define FLD(f) abuf->fields.sfmt_add.f
2786 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2787 
  int UNUSED written = 0;
2788 
  IADDR UNUSED pc = abuf->addr;
2789 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2790 
 
2791 
{
2792 
  SI tmp_result1;
2793 
  SI tmp_result0;
2794 
  tmp_result0 = ((LTDI (ADDDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 1))), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (ADDDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 1))), SLLDI (1, SUBSI (32, 1)))) ? (ADDDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 1)))) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
2795 
  tmp_result1 = ((LTDI (ADDDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 0))), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (ADDDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 0))), SLLDI (1, SUBSI (32, 1)))) ? (ADDDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 0)))) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
2796 
  {
2797 
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
2798 
    SET_H_GR (FLD (f_dest), opval);
2799 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2800 
  }
2801 
}
2802 
 
2803 
  return vpc;
2804 
#undef FLD
2805 
}
2806 
 
2807 
/* maddsub: madds.ub $rm, $rn, $rd */
2808 
 
2809 
static SEM_PC
2810 
SEM_FN_NAME (sh64_media,maddsub) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2811 
{
2812 
#define FLD(f) abuf->fields.sfmt_add.f
2813 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2814 
  int UNUSED written = 0;
2815 
  IADDR UNUSED pc = abuf->addr;
2816 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2817 
 
2818 
{
2819 
  QI tmp_result7;
2820 
  QI tmp_result6;
2821 
  QI tmp_result5;
2822 
  QI tmp_result4;
2823 
  QI tmp_result3;
2824 
  QI tmp_result2;
2825 
  QI tmp_result1;
2826 
  QI tmp_result0;
2827 
  tmp_result0 = ((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7))), MAKEDI (0, 0))) ? (0) : (((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7))), SLLDI (1, 8))) ? (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7)))) : (SUBQI (SLLQI (1, 8), 1)))));
2828 
  tmp_result1 = ((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6))), MAKEDI (0, 0))) ? (0) : (((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6))), SLLDI (1, 8))) ? (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6)))) : (SUBQI (SLLQI (1, 8), 1)))));
2829 
  tmp_result2 = ((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5))), MAKEDI (0, 0))) ? (0) : (((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5))), SLLDI (1, 8))) ? (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5)))) : (SUBQI (SLLQI (1, 8), 1)))));
2830 
  tmp_result3 = ((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4))), MAKEDI (0, 0))) ? (0) : (((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4))), SLLDI (1, 8))) ? (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4)))) : (SUBQI (SLLQI (1, 8), 1)))));
2831 
  tmp_result4 = ((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3))), MAKEDI (0, 0))) ? (0) : (((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3))), SLLDI (1, 8))) ? (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3)))) : (SUBQI (SLLQI (1, 8), 1)))));
2832 
  tmp_result5 = ((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2))), MAKEDI (0, 0))) ? (0) : (((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2))), SLLDI (1, 8))) ? (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2)))) : (SUBQI (SLLQI (1, 8), 1)))));
2833 
  tmp_result6 = ((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1))), MAKEDI (0, 0))) ? (0) : (((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1))), SLLDI (1, 8))) ? (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1)))) : (SUBQI (SLLQI (1, 8), 1)))));
2834 
  tmp_result7 = ((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0))), MAKEDI (0, 0))) ? (0) : (((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0))), SLLDI (1, 8))) ? (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0)))) : (SUBQI (SLLQI (1, 8), 1)))));
2835 
  {
2836 
    DI opval = ORDI (SLLDI (ZEXTQIDI (tmp_result7), 56), ORDI (SLLDI (ZEXTQIDI (tmp_result6), 48), ORDI (SLLDI (ZEXTQIDI (tmp_result5), 40), ORDI (SLLDI (ZEXTQIDI (tmp_result4), 32), ORDI (SLLDI (ZEXTQIDI (tmp_result3), 24), ORDI (SLLDI (ZEXTQIDI (tmp_result2), 16), ORDI (SLLDI (ZEXTQIDI (tmp_result1), 8), ZEXTQIDI (tmp_result0))))))));
2837 
    SET_H_GR (FLD (f_dest), opval);
2838 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2839 
  }
2840 
}
2841 
 
2842 
  return vpc;
2843 
#undef FLD
2844 
}
2845 
 
2846 
/* maddsw: madds.w $rm, $rn, $rd */
2847 
 
2848 
static SEM_PC
2849 
SEM_FN_NAME (sh64_media,maddsw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2850 
{
2851 
#define FLD(f) abuf->fields.sfmt_add.f
2852 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2853 
  int UNUSED written = 0;
2854 
  IADDR UNUSED pc = abuf->addr;
2855 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2856 
 
2857 
{
2858 
  HI tmp_result3;
2859 
  HI tmp_result2;
2860 
  HI tmp_result1;
2861 
  HI tmp_result0;
2862 
  tmp_result0 = ((LTDI (ADDDI (EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3)), EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3))), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (ADDDI (EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3)), EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3))), SLLDI (1, SUBSI (16, 1)))) ? (ADDDI (EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3)), EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3)))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
2863 
  tmp_result1 = ((LTDI (ADDDI (EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2)), EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2))), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (ADDDI (EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2)), EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2))), SLLDI (1, SUBSI (16, 1)))) ? (ADDDI (EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2)), EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2)))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
2864 
  tmp_result2 = ((LTDI (ADDDI (EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1)), EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1))), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (ADDDI (EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1)), EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1))), SLLDI (1, SUBSI (16, 1)))) ? (ADDDI (EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1)), EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1)))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
2865 
  tmp_result3 = ((LTDI (ADDDI (EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0)), EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0))), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (ADDDI (EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0)), EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0))), SLLDI (1, SUBSI (16, 1)))) ? (ADDDI (EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0)), EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0)))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
2866 
  {
2867 
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
2868 
    SET_H_GR (FLD (f_dest), opval);
2869 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2870 
  }
2871 
}
2872 
 
2873 
  return vpc;
2874 
#undef FLD
2875 
}
2876 
 
2877 
/* mcmpeqb: mcmpeq.b $rm, $rn, $rd */
2878 
 
2879 
static SEM_PC
2880 
SEM_FN_NAME (sh64_media,mcmpeqb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2881 
{
2882 
#define FLD(f) abuf->fields.sfmt_add.f
2883 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2884 
  int UNUSED written = 0;
2885 
  IADDR UNUSED pc = abuf->addr;
2886 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2887 
 
2888 
{
2889 
  QI tmp_result7;
2890 
  QI tmp_result6;
2891 
  QI tmp_result5;
2892 
  QI tmp_result4;
2893 
  QI tmp_result3;
2894 
  QI tmp_result2;
2895 
  QI tmp_result1;
2896 
  QI tmp_result0;
2897 
  tmp_result0 = ((EQQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7))) ? (INVQI (0)) : (0));
2898 
  tmp_result1 = ((EQQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6))) ? (INVQI (0)) : (0));
2899 
  tmp_result2 = ((EQQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5))) ? (INVQI (0)) : (0));
2900 
  tmp_result3 = ((EQQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4))) ? (INVQI (0)) : (0));
2901 
  tmp_result4 = ((EQQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3))) ? (INVQI (0)) : (0));
2902 
  tmp_result5 = ((EQQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2))) ? (INVQI (0)) : (0));
2903 
  tmp_result6 = ((EQQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1))) ? (INVQI (0)) : (0));
2904 
  tmp_result7 = ((EQQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0))) ? (INVQI (0)) : (0));
2905 
  {
2906 
    DI opval = ORDI (SLLDI (ZEXTQIDI (tmp_result7), 56), ORDI (SLLDI (ZEXTQIDI (tmp_result6), 48), ORDI (SLLDI (ZEXTQIDI (tmp_result5), 40), ORDI (SLLDI (ZEXTQIDI (tmp_result4), 32), ORDI (SLLDI (ZEXTQIDI (tmp_result3), 24), ORDI (SLLDI (ZEXTQIDI (tmp_result2), 16), ORDI (SLLDI (ZEXTQIDI (tmp_result1), 8), ZEXTQIDI (tmp_result0))))))));
2907 
    SET_H_GR (FLD (f_dest), opval);
2908 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2909 
  }
2910 
}
2911 
 
2912 
  return vpc;
2913 
#undef FLD
2914 
}
2915 
 
2916 
/* mcmpeql: mcmpeq.l $rm, $rn, $rd */
2917 
 
2918 
static SEM_PC
2919 
SEM_FN_NAME (sh64_media,mcmpeql) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2920 
{
2921 
#define FLD(f) abuf->fields.sfmt_add.f
2922 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2923 
  int UNUSED written = 0;
2924 
  IADDR UNUSED pc = abuf->addr;
2925 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2926 
 
2927 
{
2928 
  SI tmp_result1;
2929 
  SI tmp_result0;
2930 
  tmp_result0 = ((EQSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), SUBWORDDISI (GET_H_GR (FLD (f_right)), 1))) ? (INVSI (0)) : (0));
2931 
  tmp_result1 = ((EQSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), SUBWORDDISI (GET_H_GR (FLD (f_right)), 0))) ? (INVSI (0)) : (0));
2932 
  {
2933 
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
2934 
    SET_H_GR (FLD (f_dest), opval);
2935 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2936 
  }
2937 
}
2938 
 
2939 
  return vpc;
2940 
#undef FLD
2941 
}
2942 
 
2943 
/* mcmpeqw: mcmpeq.w $rm, $rn, $rd */
2944 
 
2945 
static SEM_PC
2946 
SEM_FN_NAME (sh64_media,mcmpeqw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2947 
{
2948 
#define FLD(f) abuf->fields.sfmt_add.f
2949 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2950 
  int UNUSED written = 0;
2951 
  IADDR UNUSED pc = abuf->addr;
2952 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2953 
 
2954 
{
2955 
  HI tmp_result3;
2956 
  HI tmp_result2;
2957 
  HI tmp_result1;
2958 
  HI tmp_result0;
2959 
  tmp_result0 = ((EQHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3))) ? (INVHI (0)) : (0));
2960 
  tmp_result1 = ((EQHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2))) ? (INVHI (0)) : (0));
2961 
  tmp_result2 = ((EQHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1))) ? (INVHI (0)) : (0));
2962 
  tmp_result3 = ((EQHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0))) ? (INVHI (0)) : (0));
2963 
  {
2964 
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
2965 
    SET_H_GR (FLD (f_dest), opval);
2966 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2967 
  }
2968 
}
2969 
 
2970 
  return vpc;
2971 
#undef FLD
2972 
}
2973 
 
2974 
/* mcmpgtl: mcmpgt.l $rm, $rn, $rd */
2975 
 
2976 
static SEM_PC
2977 
SEM_FN_NAME (sh64_media,mcmpgtl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2978 
{
2979 
#define FLD(f) abuf->fields.sfmt_add.f
2980 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2981 
  int UNUSED written = 0;
2982 
  IADDR UNUSED pc = abuf->addr;
2983 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2984 
 
2985 
{
2986 
  SI tmp_result1;
2987 
  SI tmp_result0;
2988 
  tmp_result0 = ((GTSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), SUBWORDDISI (GET_H_GR (FLD (f_right)), 1))) ? (INVSI (0)) : (0));
2989 
  tmp_result1 = ((GTSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), SUBWORDDISI (GET_H_GR (FLD (f_right)), 0))) ? (INVSI (0)) : (0));
2990 
  {
2991 
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
2992 
    SET_H_GR (FLD (f_dest), opval);
2993 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2994 
  }
2995 
}
2996 
 
2997 
  return vpc;
2998 
#undef FLD
2999 
}
3000 
 
3001 
/* mcmpgtub: mcmpgt.ub $rm, $rn, $rd */
3002 
 
3003 
static SEM_PC
3004 
SEM_FN_NAME (sh64_media,mcmpgtub) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3005 
{
3006 
#define FLD(f) abuf->fields.sfmt_add.f
3007 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3008 
  int UNUSED written = 0;
3009 
  IADDR UNUSED pc = abuf->addr;
3010 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3011 
 
3012 
{
3013 
  QI tmp_result7;
3014 
  QI tmp_result6;
3015 
  QI tmp_result5;
3016 
  QI tmp_result4;
3017 
  QI tmp_result3;
3018 
  QI tmp_result2;
3019 
  QI tmp_result1;
3020 
  QI tmp_result0;
3021 
  tmp_result0 = ((GTUQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7))) ? (INVQI (0)) : (0));
3022 
  tmp_result1 = ((GTUQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6))) ? (INVQI (0)) : (0));
3023 
  tmp_result2 = ((GTUQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5))) ? (INVQI (0)) : (0));
3024 
  tmp_result3 = ((GTUQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4))) ? (INVQI (0)) : (0));
3025 
  tmp_result4 = ((GTUQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3))) ? (INVQI (0)) : (0));
3026 
  tmp_result5 = ((GTUQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2))) ? (INVQI (0)) : (0));
3027 
  tmp_result6 = ((GTUQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1))) ? (INVQI (0)) : (0));
3028 
  tmp_result7 = ((GTUQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0))) ? (INVQI (0)) : (0));
3029 
  {
3030 
    DI opval = ORDI (SLLDI (ZEXTQIDI (tmp_result7), 56), ORDI (SLLDI (ZEXTQIDI (tmp_result6), 48), ORDI (SLLDI (ZEXTQIDI (tmp_result5), 40), ORDI (SLLDI (ZEXTQIDI (tmp_result4), 32), ORDI (SLLDI (ZEXTQIDI (tmp_result3), 24), ORDI (SLLDI (ZEXTQIDI (tmp_result2), 16), ORDI (SLLDI (ZEXTQIDI (tmp_result1), 8), ZEXTQIDI (tmp_result0))))))));
3031 
    SET_H_GR (FLD (f_dest), opval);
3032 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3033 
  }
3034 
}
3035 
 
3036 
  return vpc;
3037 
#undef FLD
3038 
}
3039 
 
3040 
/* mcmpgtw: mcmpgt.w $rm, $rn, $rd */
3041 
 
3042 
static SEM_PC
3043 
SEM_FN_NAME (sh64_media,mcmpgtw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3044 
{
3045 
#define FLD(f) abuf->fields.sfmt_add.f
3046 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3047 
  int UNUSED written = 0;
3048 
  IADDR UNUSED pc = abuf->addr;
3049 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3050 
 
3051 
{
3052 
  HI tmp_result3;
3053 
  HI tmp_result2;
3054 
  HI tmp_result1;
3055 
  HI tmp_result0;
3056 
  tmp_result0 = ((GTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3))) ? (INVHI (0)) : (0));
3057 
  tmp_result1 = ((GTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2))) ? (INVHI (0)) : (0));
3058 
  tmp_result2 = ((GTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1))) ? (INVHI (0)) : (0));
3059 
  tmp_result3 = ((GTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0))) ? (INVHI (0)) : (0));
3060 
  {
3061 
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
3062 
    SET_H_GR (FLD (f_dest), opval);
3063 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3064 
  }
3065 
}
3066 
 
3067 
  return vpc;
3068 
#undef FLD
3069 
}
3070 
 
3071 
/* mcmv: mcmv $rm, $rn, $rd */
3072 
 
3073 
static SEM_PC
3074 
SEM_FN_NAME (sh64_media,mcmv) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3075 
{
3076 
#define FLD(f) abuf->fields.sfmt_add.f
3077 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3078 
  int UNUSED written = 0;
3079 
  IADDR UNUSED pc = abuf->addr;
3080 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3081 
 
3082 
  {
3083 
    DI opval = ORDI (ANDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right))), ANDDI (GET_H_GR (FLD (f_dest)), INVDI (GET_H_GR (FLD (f_right)))));
3084 
    SET_H_GR (FLD (f_dest), opval);
3085 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3086 
  }
3087 
 
3088 
  return vpc;
3089 
#undef FLD
3090 
}
3091 
 
3092 
/* mcnvslw: mcnvs.lw $rm, $rn, $rd */
3093 
 
3094 
static SEM_PC
3095 
SEM_FN_NAME (sh64_media,mcnvslw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3096 
{
3097 
#define FLD(f) abuf->fields.sfmt_add.f
3098 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3099 
  int UNUSED written = 0;
3100 
  IADDR UNUSED pc = abuf->addr;
3101 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3102 
 
3103 
{
3104 
  HI tmp_result3;
3105 
  HI tmp_result2;
3106 
  HI tmp_result1;
3107 
  HI tmp_result0;
3108 
  tmp_result0 = ((LTSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), SLLDI (1, SUBSI (16, 1)))) ? (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1)) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3109 
  tmp_result1 = ((LTSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), SLLDI (1, SUBSI (16, 1)))) ? (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0)) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3110 
  tmp_result2 = ((LTSI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 1), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTSI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 1), SLLDI (1, SUBSI (16, 1)))) ? (SUBWORDDISI (GET_H_GR (FLD (f_right)), 1)) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3111 
  tmp_result3 = ((LTSI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 0), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTSI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 0), SLLDI (1, SUBSI (16, 1)))) ? (SUBWORDDISI (GET_H_GR (FLD (f_right)), 0)) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3112 
  {
3113 
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
3114 
    SET_H_GR (FLD (f_dest), opval);
3115 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3116 
  }
3117 
}
3118 
 
3119 
  return vpc;
3120 
#undef FLD
3121 
}
3122 
 
3123 
/* mcnvswb: mcnvs.wb $rm, $rn, $rd */
3124 
 
3125 
static SEM_PC
3126 
SEM_FN_NAME (sh64_media,mcnvswb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3127 
{
3128 
#define FLD(f) abuf->fields.sfmt_add.f
3129 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3130 
  int UNUSED written = 0;
3131 
  IADDR UNUSED pc = abuf->addr;
3132 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3133 
 
3134 
{
3135 
  QI tmp_result7;
3136 
  QI tmp_result6;
3137 
  QI tmp_result5;
3138 
  QI tmp_result4;
3139 
  QI tmp_result3;
3140 
  QI tmp_result2;
3141 
  QI tmp_result1;
3142 
  QI tmp_result0;
3143 
  tmp_result0 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), NEGDI (SLLDI (1, SUBSI (8, 1))))) ? (NEGQI (SLLQI (1, SUBSI (8, 1)))) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), SLLDI (1, SUBSI (8, 1)))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3)) : (SUBQI (SLLQI (1, SUBSI (8, 1)), 1)))));
3144 
  tmp_result1 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), NEGDI (SLLDI (1, SUBSI (8, 1))))) ? (NEGQI (SLLQI (1, SUBSI (8, 1)))) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), SLLDI (1, SUBSI (8, 1)))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2)) : (SUBQI (SLLQI (1, SUBSI (8, 1)), 1)))));
3145 
  tmp_result2 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), NEGDI (SLLDI (1, SUBSI (8, 1))))) ? (NEGQI (SLLQI (1, SUBSI (8, 1)))) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), SLLDI (1, SUBSI (8, 1)))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1)) : (SUBQI (SLLQI (1, SUBSI (8, 1)), 1)))));
3146 
  tmp_result3 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), NEGDI (SLLDI (1, SUBSI (8, 1))))) ? (NEGQI (SLLQI (1, SUBSI (8, 1)))) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), SLLDI (1, SUBSI (8, 1)))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0)) : (SUBQI (SLLQI (1, SUBSI (8, 1)), 1)))));
3147 
  tmp_result4 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3), NEGDI (SLLDI (1, SUBSI (8, 1))))) ? (NEGQI (SLLQI (1, SUBSI (8, 1)))) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3), SLLDI (1, SUBSI (8, 1)))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3)) : (SUBQI (SLLQI (1, SUBSI (8, 1)), 1)))));
3148 
  tmp_result5 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2), NEGDI (SLLDI (1, SUBSI (8, 1))))) ? (NEGQI (SLLQI (1, SUBSI (8, 1)))) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2), SLLDI (1, SUBSI (8, 1)))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2)) : (SUBQI (SLLQI (1, SUBSI (8, 1)), 1)))));
3149 
  tmp_result6 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1), NEGDI (SLLDI (1, SUBSI (8, 1))))) ? (NEGQI (SLLQI (1, SUBSI (8, 1)))) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1), SLLDI (1, SUBSI (8, 1)))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1)) : (SUBQI (SLLQI (1, SUBSI (8, 1)), 1)))));
3150 
  tmp_result7 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0), NEGDI (SLLDI (1, SUBSI (8, 1))))) ? (NEGQI (SLLQI (1, SUBSI (8, 1)))) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0), SLLDI (1, SUBSI (8, 1)))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0)) : (SUBQI (SLLQI (1, SUBSI (8, 1)), 1)))));
3151 
  {
3152 
    DI opval = ORDI (SLLDI (ZEXTQIDI (tmp_result7), 56), ORDI (SLLDI (ZEXTQIDI (tmp_result6), 48), ORDI (SLLDI (ZEXTQIDI (tmp_result5), 40), ORDI (SLLDI (ZEXTQIDI (tmp_result4), 32), ORDI (SLLDI (ZEXTQIDI (tmp_result3), 24), ORDI (SLLDI (ZEXTQIDI (tmp_result2), 16), ORDI (SLLDI (ZEXTQIDI (tmp_result1), 8), ZEXTQIDI (tmp_result0))))))));
3153 
    SET_H_GR (FLD (f_dest), opval);
3154 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3155 
  }
3156 
}
3157 
 
3158 
  return vpc;
3159 
#undef FLD
3160 
}
3161 
 
3162 
/* mcnvswub: mcnvs.wub $rm, $rn, $rd */
3163 
 
3164 
static SEM_PC
3165 
SEM_FN_NAME (sh64_media,mcnvswub) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3166 
{
3167 
#define FLD(f) abuf->fields.sfmt_add.f
3168 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3169 
  int UNUSED written = 0;
3170 
  IADDR UNUSED pc = abuf->addr;
3171 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3172 
 
3173 
{
3174 
  QI tmp_result7;
3175 
  QI tmp_result6;
3176 
  QI tmp_result5;
3177 
  QI tmp_result4;
3178 
  QI tmp_result3;
3179 
  QI tmp_result2;
3180 
  QI tmp_result1;
3181 
  QI tmp_result0;
3182 
  tmp_result0 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), MAKEDI (0, 0))) ? (0) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), SLLDI (1, 8))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3)) : (SUBQI (SLLQI (1, 8), 1)))));
3183 
  tmp_result1 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), MAKEDI (0, 0))) ? (0) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), SLLDI (1, 8))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2)) : (SUBQI (SLLQI (1, 8), 1)))));
3184 
  tmp_result2 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), MAKEDI (0, 0))) ? (0) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), SLLDI (1, 8))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1)) : (SUBQI (SLLQI (1, 8), 1)))));
3185 
  tmp_result3 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), MAKEDI (0, 0))) ? (0) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), SLLDI (1, 8))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0)) : (SUBQI (SLLQI (1, 8), 1)))));
3186 
  tmp_result4 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3), MAKEDI (0, 0))) ? (0) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3), SLLDI (1, 8))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3)) : (SUBQI (SLLQI (1, 8), 1)))));
3187 
  tmp_result5 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2), MAKEDI (0, 0))) ? (0) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2), SLLDI (1, 8))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2)) : (SUBQI (SLLQI (1, 8), 1)))));
3188 
  tmp_result6 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1), MAKEDI (0, 0))) ? (0) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1), SLLDI (1, 8))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1)) : (SUBQI (SLLQI (1, 8), 1)))));
3189 
  tmp_result7 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0), MAKEDI (0, 0))) ? (0) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0), SLLDI (1, 8))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0)) : (SUBQI (SLLQI (1, 8), 1)))));
3190 
  {
3191 
    DI opval = ORDI (SLLDI (ZEXTQIDI (tmp_result7), 56), ORDI (SLLDI (ZEXTQIDI (tmp_result6), 48), ORDI (SLLDI (ZEXTQIDI (tmp_result5), 40), ORDI (SLLDI (ZEXTQIDI (tmp_result4), 32), ORDI (SLLDI (ZEXTQIDI (tmp_result3), 24), ORDI (SLLDI (ZEXTQIDI (tmp_result2), 16), ORDI (SLLDI (ZEXTQIDI (tmp_result1), 8), ZEXTQIDI (tmp_result0))))))));
3192 
    SET_H_GR (FLD (f_dest), opval);
3193 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3194 
  }
3195 
}
3196 
 
3197 
  return vpc;
3198 
#undef FLD
3199 
}
3200 
 
3201 
/* mextr1: mextr1 $rm, $rn, $rd */
3202 
 
3203 
static SEM_PC
3204 
SEM_FN_NAME (sh64_media,mextr1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3205 
{
3206 
#define FLD(f) abuf->fields.sfmt_add.f
3207 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3208 
  int UNUSED written = 0;
3209 
  IADDR UNUSED pc = abuf->addr;
3210 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3211 
 
3212 
{
3213 
  QI tmp_count;
3214 
  DI tmp_mask;
3215 
  DI tmp_rhs;
3216 
  tmp_count = MULQI (8, 1);
3217 
  tmp_mask = SLLDI (INVSI (0), tmp_count);
3218 
  tmp_rhs = SRLDI (ANDDI (GET_H_GR (FLD (f_left)), tmp_mask), tmp_count);
3219 
  tmp_count = MULQI (8, SUBQI (8, 1));
3220 
  tmp_mask = SRLDI (INVSI (0), tmp_count);
3221 
  {
3222 
    DI opval = ORDI (tmp_rhs, SLLDI (ANDDI (GET_H_GR (FLD (f_right)), tmp_mask), tmp_count));
3223 
    SET_H_GR (FLD (f_dest), opval);
3224 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3225 
  }
3226 
}
3227 
 
3228 
  return vpc;
3229 
#undef FLD
3230 
}
3231 
 
3232 
/* mextr2: mextr2 $rm, $rn, $rd */
3233 
 
3234 
static SEM_PC
3235 
SEM_FN_NAME (sh64_media,mextr2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3236 
{
3237 
#define FLD(f) abuf->fields.sfmt_add.f
3238 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3239 
  int UNUSED written = 0;
3240 
  IADDR UNUSED pc = abuf->addr;
3241 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3242 
 
3243 
{
3244 
  QI tmp_count;
3245 
  DI tmp_mask;
3246 
  DI tmp_rhs;
3247 
  tmp_count = MULQI (8, 2);
3248 
  tmp_mask = SLLDI (INVSI (0), tmp_count);
3249 
  tmp_rhs = SRLDI (ANDDI (GET_H_GR (FLD (f_left)), tmp_mask), tmp_count);
3250 
  tmp_count = MULQI (8, SUBQI (8, 2));
3251 
  tmp_mask = SRLDI (INVSI (0), tmp_count);
3252 
  {
3253 
    DI opval = ORDI (tmp_rhs, SLLDI (ANDDI (GET_H_GR (FLD (f_right)), tmp_mask), tmp_count));
3254 
    SET_H_GR (FLD (f_dest), opval);
3255 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3256 
  }
3257 
}
3258 
 
3259 
  return vpc;
3260 
#undef FLD
3261 
}
3262 
 
3263 
/* mextr3: mextr3 $rm, $rn, $rd */
3264 
 
3265 
static SEM_PC
3266 
SEM_FN_NAME (sh64_media,mextr3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3267 
{
3268 
#define FLD(f) abuf->fields.sfmt_add.f
3269 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3270 
  int UNUSED written = 0;
3271 
  IADDR UNUSED pc = abuf->addr;
3272 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3273 
 
3274 
{
3275 
  QI tmp_count;
3276 
  DI tmp_mask;
3277 
  DI tmp_rhs;
3278 
  tmp_count = MULQI (8, 3);
3279 
  tmp_mask = SLLDI (INVSI (0), tmp_count);
3280 
  tmp_rhs = SRLDI (ANDDI (GET_H_GR (FLD (f_left)), tmp_mask), tmp_count);
3281 
  tmp_count = MULQI (8, SUBQI (8, 3));
3282 
  tmp_mask = SRLDI (INVSI (0), tmp_count);
3283 
  {
3284 
    DI opval = ORDI (tmp_rhs, SLLDI (ANDDI (GET_H_GR (FLD (f_right)), tmp_mask), tmp_count));
3285 
    SET_H_GR (FLD (f_dest), opval);
3286 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3287 
  }
3288 
}
3289 
 
3290 
  return vpc;
3291 
#undef FLD
3292 
}
3293 
 
3294 
/* mextr4: mextr4 $rm, $rn, $rd */
3295 
 
3296 
static SEM_PC
3297 
SEM_FN_NAME (sh64_media,mextr4) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3298 
{
3299 
#define FLD(f) abuf->fields.sfmt_add.f
3300 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3301 
  int UNUSED written = 0;
3302 
  IADDR UNUSED pc = abuf->addr;
3303 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3304 
 
3305 
{
3306 
  QI tmp_count;
3307 
  DI tmp_mask;
3308 
  DI tmp_rhs;
3309 
  tmp_count = MULQI (8, 4);
3310 
  tmp_mask = SLLDI (INVSI (0), tmp_count);
3311 
  tmp_rhs = SRLDI (ANDDI (GET_H_GR (FLD (f_left)), tmp_mask), tmp_count);
3312 
  tmp_count = MULQI (8, SUBQI (8, 4));
3313 
  tmp_mask = SRLDI (INVSI (0), tmp_count);
3314 
  {
3315 
    DI opval = ORDI (tmp_rhs, SLLDI (ANDDI (GET_H_GR (FLD (f_right)), tmp_mask), tmp_count));
3316 
    SET_H_GR (FLD (f_dest), opval);
3317 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3318 
  }
3319 
}
3320 
 
3321 
  return vpc;
3322 
#undef FLD
3323 
}
3324 
 
3325 
/* mextr5: mextr5 $rm, $rn, $rd */
3326 
 
3327 
static SEM_PC
3328 
SEM_FN_NAME (sh64_media,mextr5) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3329 
{
3330 
#define FLD(f) abuf->fields.sfmt_add.f
3331 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3332 
  int UNUSED written = 0;
3333 
  IADDR UNUSED pc = abuf->addr;
3334 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3335 
 
3336 
{
3337 
  QI tmp_count;
3338 
  DI tmp_mask;
3339 
  DI tmp_rhs;
3340 
  tmp_count = MULQI (8, 5);
3341 
  tmp_mask = SLLDI (INVSI (0), tmp_count);
3342 
  tmp_rhs = SRLDI (ANDDI (GET_H_GR (FLD (f_left)), tmp_mask), tmp_count);
3343 
  tmp_count = MULQI (8, SUBQI (8, 5));
3344 
  tmp_mask = SRLDI (INVSI (0), tmp_count);
3345 
  {
3346 
    DI opval = ORDI (tmp_rhs, SLLDI (ANDDI (GET_H_GR (FLD (f_right)), tmp_mask), tmp_count));
3347 
    SET_H_GR (FLD (f_dest), opval);
3348 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3349 
  }
3350 
}
3351 
 
3352 
  return vpc;
3353 
#undef FLD
3354 
}
3355 
 
3356 
/* mextr6: mextr6 $rm, $rn, $rd */
3357 
 
3358 
static SEM_PC
3359 
SEM_FN_NAME (sh64_media,mextr6) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3360 
{
3361 
#define FLD(f) abuf->fields.sfmt_add.f
3362 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3363 
  int UNUSED written = 0;
3364 
  IADDR UNUSED pc = abuf->addr;
3365 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3366 
 
3367 
{
3368 
  QI tmp_count;
3369 
  DI tmp_mask;
3370 
  DI tmp_rhs;
3371 
  tmp_count = MULQI (8, 6);
3372 
  tmp_mask = SLLDI (INVSI (0), tmp_count);
3373 
  tmp_rhs = SRLDI (ANDDI (GET_H_GR (FLD (f_left)), tmp_mask), tmp_count);
3374 
  tmp_count = MULQI (8, SUBQI (8, 6));
3375 
  tmp_mask = SRLDI (INVSI (0), tmp_count);
3376 
  {
3377 
    DI opval = ORDI (tmp_rhs, SLLDI (ANDDI (GET_H_GR (FLD (f_right)), tmp_mask), tmp_count));
3378 
    SET_H_GR (FLD (f_dest), opval);
3379 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3380 
  }
3381 
}
3382 
 
3383 
  return vpc;
3384 
#undef FLD
3385 
}
3386 
 
3387 
/* mextr7: mextr7 $rm, $rn, $rd */
3388 
 
3389 
static SEM_PC
3390 
SEM_FN_NAME (sh64_media,mextr7) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3391 
{
3392 
#define FLD(f) abuf->fields.sfmt_add.f
3393 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3394 
  int UNUSED written = 0;
3395 
  IADDR UNUSED pc = abuf->addr;
3396 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3397 
 
3398 
{
3399 
  QI tmp_count;
3400 
  DI tmp_mask;
3401 
  DI tmp_rhs;
3402 
  tmp_count = MULQI (8, 7);
3403 
  tmp_mask = SLLDI (INVSI (0), tmp_count);
3404 
  tmp_rhs = SRLDI (ANDDI (GET_H_GR (FLD (f_left)), tmp_mask), tmp_count);
3405 
  tmp_count = MULQI (8, SUBQI (8, 7));
3406 
  tmp_mask = SRLDI (INVSI (0), tmp_count);
3407 
  {
3408 
    DI opval = ORDI (tmp_rhs, SLLDI (ANDDI (GET_H_GR (FLD (f_right)), tmp_mask), tmp_count));
3409 
    SET_H_GR (FLD (f_dest), opval);
3410 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3411 
  }
3412 
}
3413 
 
3414 
  return vpc;
3415 
#undef FLD
3416 
}
3417 
 
3418 
/* mmacfxwl: mmacfx.wl $rm, $rn, $rd */
3419 
 
3420 
static SEM_PC
3421 
SEM_FN_NAME (sh64_media,mmacfxwl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3422 
{
3423 
#define FLD(f) abuf->fields.sfmt_add.f
3424 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3425 
  int UNUSED written = 0;
3426 
  IADDR UNUSED pc = abuf->addr;
3427 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3428 
 
3429 
{
3430 
  SI tmp_temp;
3431 
  SI tmp_result1;
3432 
  SI tmp_result0;
3433 
  tmp_result0 = SUBWORDDISI (GET_H_GR (FLD (f_dest)), 1);
3434 
  tmp_result1 = SUBWORDDISI (GET_H_GR (FLD (f_dest)), 0);
3435 
  tmp_temp = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3)));
3436 
  tmp_temp = ((LTDI (SLLDI (tmp_temp, 1), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (SLLDI (tmp_temp, 1), SLLDI (1, SUBSI (32, 1)))) ? (SLLDI (tmp_temp, 1)) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
3437 
  tmp_result0 = ((LTDI (ADDDI (EXTSIDI (tmp_result0), EXTSIDI (tmp_temp)), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (ADDDI (EXTSIDI (tmp_result0), EXTSIDI (tmp_temp)), SLLDI (1, SUBSI (32, 1)))) ? (ADDDI (EXTSIDI (tmp_result0), EXTSIDI (tmp_temp))) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
3438 
  tmp_temp = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2)));
3439 
  tmp_temp = ((LTDI (SLLDI (tmp_temp, 1), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (SLLDI (tmp_temp, 1), SLLDI (1, SUBSI (32, 1)))) ? (SLLDI (tmp_temp, 1)) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
3440 
  tmp_result1 = ((LTDI (ADDDI (EXTSIDI (tmp_result1), EXTSIDI (tmp_temp)), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (ADDDI (EXTSIDI (tmp_result1), EXTSIDI (tmp_temp)), SLLDI (1, SUBSI (32, 1)))) ? (ADDDI (EXTSIDI (tmp_result1), EXTSIDI (tmp_temp))) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
3441 
  {
3442 
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
3443 
    SET_H_GR (FLD (f_dest), opval);
3444 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3445 
  }
3446 
}
3447 
 
3448 
  return vpc;
3449 
#undef FLD
3450 
}
3451 
 
3452 
/* mmacnfx.wl: mmacnfx.wl $rm, $rn, $rd */
3453 
 
3454 
static SEM_PC
3455 
SEM_FN_NAME (sh64_media,mmacnfx_wl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3456 
{
3457 
#define FLD(f) abuf->fields.sfmt_add.f
3458 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3459 
  int UNUSED written = 0;
3460 
  IADDR UNUSED pc = abuf->addr;
3461 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3462 
 
3463 
{
3464 
  SI tmp_temp;
3465 
  SI tmp_result1;
3466 
  SI tmp_result0;
3467 
  tmp_result0 = SUBWORDDISI (GET_H_GR (FLD (f_dest)), 1);
3468 
  tmp_result1 = SUBWORDDISI (GET_H_GR (FLD (f_dest)), 0);
3469 
  tmp_temp = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3)));
3470 
  tmp_temp = ((LTDI (SLLDI (tmp_temp, 1), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (SLLDI (tmp_temp, 1), SLLDI (1, SUBSI (32, 1)))) ? (SLLDI (tmp_temp, 1)) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
3471 
  tmp_result0 = ((LTDI (SUBDI (EXTSIDI (tmp_result0), EXTSIDI (tmp_temp)), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (SUBDI (EXTSIDI (tmp_result0), EXTSIDI (tmp_temp)), SLLDI (1, SUBSI (32, 1)))) ? (SUBDI (EXTSIDI (tmp_result0), EXTSIDI (tmp_temp))) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
3472 
  tmp_temp = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2)));
3473 
  tmp_temp = ((LTDI (SLLDI (tmp_temp, 1), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (SLLDI (tmp_temp, 1), SLLDI (1, SUBSI (32, 1)))) ? (SLLDI (tmp_temp, 1)) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
3474 
  tmp_result1 = ((LTDI (SUBDI (EXTSIDI (tmp_result1), EXTSIDI (tmp_temp)), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (SUBDI (EXTSIDI (tmp_result1), EXTSIDI (tmp_temp)), SLLDI (1, SUBSI (32, 1)))) ? (SUBDI (EXTSIDI (tmp_result1), EXTSIDI (tmp_temp))) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
3475 
  {
3476 
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
3477 
    SET_H_GR (FLD (f_dest), opval);
3478 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3479 
  }
3480 
}
3481 
 
3482 
  return vpc;
3483 
#undef FLD
3484 
}
3485 
 
3486 
/* mmull: mmul.l $rm, $rn, $rd */
3487 
 
3488 
static SEM_PC
3489 
SEM_FN_NAME (sh64_media,mmull) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3490 
{
3491 
#define FLD(f) abuf->fields.sfmt_add.f
3492 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3493 
  int UNUSED written = 0;
3494 
  IADDR UNUSED pc = abuf->addr;
3495 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3496 
 
3497 
{
3498 
  SI tmp_result1;
3499 
  SI tmp_result0;
3500 
  tmp_result0 = MULSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), SUBWORDDISI (GET_H_GR (FLD (f_right)), 1));
3501 
  tmp_result1 = MULSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), SUBWORDDISI (GET_H_GR (FLD (f_right)), 0));
3502 
  {
3503 
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
3504 
    SET_H_GR (FLD (f_dest), opval);
3505 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3506 
  }
3507 
}
3508 
 
3509 
  return vpc;
3510 
#undef FLD
3511 
}
3512 
 
3513 
/* mmulw: mmul.w $rm, $rn, $rd */
3514 
 
3515 
static SEM_PC
3516 
SEM_FN_NAME (sh64_media,mmulw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3517 
{
3518 
#define FLD(f) abuf->fields.sfmt_add.f
3519 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3520 
  int UNUSED written = 0;
3521 
  IADDR UNUSED pc = abuf->addr;
3522 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3523 
 
3524 
{
3525 
  HI tmp_result3;
3526 
  HI tmp_result2;
3527 
  HI tmp_result1;
3528 
  HI tmp_result0;
3529 
  tmp_result0 = MULHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3));
3530 
  tmp_result1 = MULHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2));
3531 
  tmp_result2 = MULHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1));
3532 
  tmp_result3 = MULHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0));
3533 
  {
3534 
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
3535 
    SET_H_GR (FLD (f_dest), opval);
3536 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3537 
  }
3538 
}
3539 
 
3540 
  return vpc;
3541 
#undef FLD
3542 
}
3543 
 
3544 
/* mmulfxl: mmulfx.l $rm, $rn, $rd */
3545 
 
3546 
static SEM_PC
3547 
SEM_FN_NAME (sh64_media,mmulfxl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3548 
{
3549 
#define FLD(f) abuf->fields.sfmt_add.f
3550 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3551 
  int UNUSED written = 0;
3552 
  IADDR UNUSED pc = abuf->addr;
3553 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3554 
 
3555 
{
3556 
  DI tmp_temp;
3557 
  SI tmp_result0;
3558 
  SI tmp_result1;
3559 
  tmp_temp = MULDI (ZEXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1)), ZEXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 1)));
3560 
  tmp_result0 = ((LTDI (SRADI (tmp_temp, 31), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (SRADI (tmp_temp, 31), SLLDI (1, SUBSI (32, 1)))) ? (SRADI (tmp_temp, 31)) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
3561 
  tmp_temp = MULDI (ZEXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0)), ZEXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 0)));
3562 
  tmp_result1 = ((LTDI (SRADI (tmp_temp, 31), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (SRADI (tmp_temp, 31), SLLDI (1, SUBSI (32, 1)))) ? (SRADI (tmp_temp, 31)) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
3563 
  {
3564 
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
3565 
    SET_H_GR (FLD (f_dest), opval);
3566 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3567 
  }
3568 
}
3569 
 
3570 
  return vpc;
3571 
#undef FLD
3572 
}
3573 
 
3574 
/* mmulfxw: mmulfx.w $rm, $rn, $rd */
3575 
 
3576 
static SEM_PC
3577 
SEM_FN_NAME (sh64_media,mmulfxw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3578 
{
3579 
#define FLD(f) abuf->fields.sfmt_add.f
3580 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3581 
  int UNUSED written = 0;
3582 
  IADDR UNUSED pc = abuf->addr;
3583 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3584 
 
3585 
{
3586 
  SI tmp_temp;
3587 
  HI tmp_result0;
3588 
  HI tmp_result1;
3589 
  HI tmp_result2;
3590 
  HI tmp_result3;
3591 
  tmp_temp = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3)));
3592 
  tmp_result0 = ((LTSI (SRASI (tmp_temp, 15), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTSI (SRASI (tmp_temp, 15), SLLDI (1, SUBSI (16, 1)))) ? (SRASI (tmp_temp, 15)) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3593 
  tmp_temp = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2)));
3594 
  tmp_result1 = ((LTSI (SRASI (tmp_temp, 15), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTSI (SRASI (tmp_temp, 15), SLLDI (1, SUBSI (16, 1)))) ? (SRASI (tmp_temp, 15)) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3595 
  tmp_temp = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1)));
3596 
  tmp_result2 = ((LTSI (SRASI (tmp_temp, 15), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTSI (SRASI (tmp_temp, 15), SLLDI (1, SUBSI (16, 1)))) ? (SRASI (tmp_temp, 15)) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3597 
  tmp_temp = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0)));
3598 
  tmp_result3 = ((LTSI (SRASI (tmp_temp, 15), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTSI (SRASI (tmp_temp, 15), SLLDI (1, SUBSI (16, 1)))) ? (SRASI (tmp_temp, 15)) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3599 
  {
3600 
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
3601 
    SET_H_GR (FLD (f_dest), opval);
3602 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3603 
  }
3604 
}
3605 
 
3606 
  return vpc;
3607 
#undef FLD
3608 
}
3609 
 
3610 
/* mmulfxrpw: mmulfxrp.w $rm, $rn, $rd */
3611 
 
3612 
static SEM_PC
3613 
SEM_FN_NAME (sh64_media,mmulfxrpw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3614 
{
3615 
#define FLD(f) abuf->fields.sfmt_add.f
3616 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3617 
  int UNUSED written = 0;
3618 
  IADDR UNUSED pc = abuf->addr;
3619 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3620 
 
3621 
{
3622 
  SI tmp_temp;
3623 
  HI tmp_result0;
3624 
  HI tmp_result1;
3625 
  HI tmp_result2;
3626 
  HI tmp_result3;
3627 
  HI tmp_c;
3628 
  tmp_c = SLLSI (1, 14);
3629 
  tmp_temp = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3)));
3630 
  tmp_result0 = ((LTSI (SRASI (ADDSI (tmp_temp, tmp_c), 15), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTSI (SRASI (ADDSI (tmp_temp, tmp_c), 15), SLLDI (1, SUBSI (16, 1)))) ? (SRASI (ADDSI (tmp_temp, tmp_c), 15)) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3631 
  tmp_temp = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2)));
3632 
  tmp_result1 = ((LTSI (SRASI (ADDSI (tmp_temp, tmp_c), 15), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTSI (SRASI (ADDSI (tmp_temp, tmp_c), 15), SLLDI (1, SUBSI (16, 1)))) ? (SRASI (ADDSI (tmp_temp, tmp_c), 15)) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3633 
  tmp_temp = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1)));
3634 
  tmp_result2 = ((LTSI (SRASI (ADDSI (tmp_temp, tmp_c), 15), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTSI (SRASI (ADDSI (tmp_temp, tmp_c), 15), SLLDI (1, SUBSI (16, 1)))) ? (SRASI (ADDSI (tmp_temp, tmp_c), 15)) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3635 
  tmp_temp = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0)));
3636 
  tmp_result3 = ((LTSI (SRASI (ADDSI (tmp_temp, tmp_c), 15), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTSI (SRASI (ADDSI (tmp_temp, tmp_c), 15), SLLDI (1, SUBSI (16, 1)))) ? (SRASI (ADDSI (tmp_temp, tmp_c), 15)) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3637 
  {
3638 
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
3639 
    SET_H_GR (FLD (f_dest), opval);
3640 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3641 
  }
3642 
}
3643 
 
3644 
  return vpc;
3645 
#undef FLD
3646 
}
3647 
 
3648 
/* mmulhiwl: mmulhi.wl $rm, $rn, $rd */
3649 
 
3650 
static SEM_PC
3651 
SEM_FN_NAME (sh64_media,mmulhiwl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3652 
{
3653 
#define FLD(f) abuf->fields.sfmt_add.f
3654 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3655 
  int UNUSED written = 0;
3656 
  IADDR UNUSED pc = abuf->addr;
3657 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3658 
 
3659 
{
3660 
  SI tmp_result1;
3661 
  SI tmp_result0;
3662 
  tmp_result0 = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1)));
3663 
  tmp_result1 = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0)));
3664 
  {
3665 
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
3666 
    SET_H_GR (FLD (f_dest), opval);
3667 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3668 
  }
3669 
}
3670 
 
3671 
  return vpc;
3672 
#undef FLD
3673 
}
3674 
 
3675 
/* mmullowl: mmullo.wl $rm, $rn, $rd */
3676 
 
3677 
static SEM_PC
3678 
SEM_FN_NAME (sh64_media,mmullowl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3679 
{
3680 
#define FLD(f) abuf->fields.sfmt_add.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, 4);
3685 
 
3686 
{
3687 
  SI tmp_result1;
3688 
  SI tmp_result0;
3689 
  tmp_result0 = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3)));
3690 
  tmp_result1 = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2)));
3691 
  {
3692 
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
3693 
    SET_H_GR (FLD (f_dest), opval);
3694 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3695 
  }
3696 
}
3697 
 
3698 
  return vpc;
3699 
#undef FLD
3700 
}
3701 
 
3702 
/* mmulsumwq: mmulsum.wq $rm, $rn, $rd */
3703 
 
3704 
static SEM_PC
3705 
SEM_FN_NAME (sh64_media,mmulsumwq) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3706 
{
3707 
#define FLD(f) abuf->fields.sfmt_add.f
3708 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3709 
  int UNUSED written = 0;
3710 
  IADDR UNUSED pc = abuf->addr;
3711 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3712 
 
3713 
{
3714 
  DI tmp_acc;
3715 
  tmp_acc = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0)));
3716 
  tmp_acc = ADDDI (tmp_acc, MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1))));
3717 
  tmp_acc = ADDDI (tmp_acc, MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2))));
3718 
  tmp_acc = ADDDI (tmp_acc, MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3))));
3719 
  {
3720 
    DI opval = ADDDI (GET_H_GR (FLD (f_dest)), tmp_acc);
3721 
    SET_H_GR (FLD (f_dest), opval);
3722 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3723 
  }
3724 
}
3725 
 
3726 
  return vpc;
3727 
#undef FLD
3728 
}
3729 
 
3730 
/* movi: movi $imm16, $rd */
3731 
 
3732 
static SEM_PC
3733 
SEM_FN_NAME (sh64_media,movi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3734 
{
3735 
#define FLD(f) abuf->fields.sfmt_movi.f
3736 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3737 
  int UNUSED written = 0;
3738 
  IADDR UNUSED pc = abuf->addr;
3739 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3740 
 
3741 
  {
3742 
    DI opval = EXTSIDI (FLD (f_imm16));
3743 
    SET_H_GR (FLD (f_dest), opval);
3744 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3745 
  }
3746 
 
3747 
  return vpc;
3748 
#undef FLD
3749 
}
3750 
 
3751 
/* mpermw: mperm.w $rm, $rn, $rd */
3752 
 
3753 
static SEM_PC
3754 
SEM_FN_NAME (sh64_media,mpermw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3755 
{
3756 
#define FLD(f) abuf->fields.sfmt_add.f
3757 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3758 
  int UNUSED written = 0;
3759 
  IADDR UNUSED pc = abuf->addr;
3760 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3761 
 
3762 
{
3763 
  QI tmp_control;
3764 
  HI tmp_result3;
3765 
  HI tmp_result2;
3766 
  HI tmp_result1;
3767 
  HI tmp_result0;
3768 
  tmp_control = ANDQI (GET_H_GR (FLD (f_right)), 255);
3769 
  tmp_result0 = SUBWORDDIHI (GET_H_GR (FLD (f_left)), SUBSI (3, ANDQI (tmp_control, 3)));
3770 
  tmp_result1 = SUBWORDDIHI (GET_H_GR (FLD (f_left)), SUBSI (3, ANDQI (SRLQI (tmp_control, 2), 3)));
3771 
  tmp_result2 = SUBWORDDIHI (GET_H_GR (FLD (f_left)), SUBSI (3, ANDQI (SRLQI (tmp_control, 4), 3)));
3772 
  tmp_result3 = SUBWORDDIHI (GET_H_GR (FLD (f_left)), SUBSI (3, ANDQI (SRLQI (tmp_control, 6), 3)));
3773 
  {
3774 
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
3775 
    SET_H_GR (FLD (f_dest), opval);
3776 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3777 
  }
3778 
}
3779 
 
3780 
  return vpc;
3781 
#undef FLD
3782 
}
3783 
 
3784 
/* msadubq: msad.ubq $rm, $rn, $rd */
3785 
 
3786 
static SEM_PC
3787 
SEM_FN_NAME (sh64_media,msadubq) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3788 
{
3789 
#define FLD(f) abuf->fields.sfmt_add.f
3790 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3791 
  int UNUSED written = 0;
3792 
  IADDR UNUSED pc = abuf->addr;
3793 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3794 
 
3795 
{
3796 
  DI tmp_acc;
3797 
  tmp_acc = ABSDI (SUBQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0)));
3798 
  tmp_acc = ADDDI (tmp_acc, ABSQI (SUBQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1))));
3799 
  tmp_acc = ADDDI (tmp_acc, ABSQI (SUBQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2))));
3800 
  tmp_acc = ADDDI (tmp_acc, ABSQI (SUBQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3))));
3801 
  tmp_acc = ADDDI (tmp_acc, ABSQI (SUBQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4))));
3802 
  tmp_acc = ADDDI (tmp_acc, ABSQI (SUBQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5))));
3803 
  tmp_acc = ADDDI (tmp_acc, ABSQI (SUBQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6))));
3804 
  tmp_acc = ADDDI (tmp_acc, ABSQI (SUBQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7))));
3805 
  {
3806 
    DI opval = ADDDI (GET_H_GR (FLD (f_dest)), tmp_acc);
3807 
    SET_H_GR (FLD (f_dest), opval);
3808 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3809 
  }
3810 
}
3811 
 
3812 
  return vpc;
3813 
#undef FLD
3814 
}
3815 
 
3816 
/* mshaldsl: mshalds.l $rm, $rn, $rd */
3817 
 
3818 
static SEM_PC
3819 
SEM_FN_NAME (sh64_media,mshaldsl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3820 
{
3821 
#define FLD(f) abuf->fields.sfmt_add.f
3822 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3823 
  int UNUSED written = 0;
3824 
  IADDR UNUSED pc = abuf->addr;
3825 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3826 
 
3827 
{
3828 
  SI tmp_result1;
3829 
  SI tmp_result0;
3830 
  tmp_result0 = ((LTDI (SLLDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 31)), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (SLLDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 31)), SLLDI (1, SUBSI (32, 1)))) ? (SLLDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 31))) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
3831 
  tmp_result1 = ((LTDI (SLLDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), ANDDI (GET_H_GR (FLD (f_right)), 31)), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (SLLDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), ANDDI (GET_H_GR (FLD (f_right)), 31)), SLLDI (1, SUBSI (32, 1)))) ? (SLLDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), ANDDI (GET_H_GR (FLD (f_right)), 31))) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
3832 
  {
3833 
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
3834 
    SET_H_GR (FLD (f_dest), opval);
3835 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3836 
  }
3837 
}
3838 
 
3839 
  return vpc;
3840 
#undef FLD
3841 
}
3842 
 
3843 
/* mshaldsw: mshalds.w $rm, $rn, $rd */
3844 
 
3845 
static SEM_PC
3846 
SEM_FN_NAME (sh64_media,mshaldsw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3847 
{
3848 
#define FLD(f) abuf->fields.sfmt_add.f
3849 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3850 
  int UNUSED written = 0;
3851 
  IADDR UNUSED pc = abuf->addr;
3852 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3853 
 
3854 
{
3855 
  HI tmp_result3;
3856 
  HI tmp_result2;
3857 
  HI tmp_result1;
3858 
  HI tmp_result0;
3859 
  tmp_result0 = ((LTDI (SLLDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), ANDDI (GET_H_GR (FLD (f_right)), 15)), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (SLLDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), ANDDI (GET_H_GR (FLD (f_right)), 15)), SLLDI (1, SUBSI (16, 1)))) ? (SLLDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), ANDDI (GET_H_GR (FLD (f_right)), 15))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3860 
  tmp_result1 = ((LTDI (SLLDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), ANDDI (GET_H_GR (FLD (f_right)), 15)), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (SLLDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), ANDDI (GET_H_GR (FLD (f_right)), 15)), SLLDI (1, SUBSI (16, 1)))) ? (SLLDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), ANDDI (GET_H_GR (FLD (f_right)), 15))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3861 
  tmp_result2 = ((LTDI (SLLDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 15)), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (SLLDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 15)), SLLDI (1, SUBSI (16, 1)))) ? (SLLDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 15))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3862 
  tmp_result3 = ((LTDI (SLLDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), ANDDI (GET_H_GR (FLD (f_right)), 15)), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (SLLDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), ANDDI (GET_H_GR (FLD (f_right)), 15)), SLLDI (1, SUBSI (16, 1)))) ? (SLLDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), ANDDI (GET_H_GR (FLD (f_right)), 15))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3863 
  {
3864 
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
3865 
    SET_H_GR (FLD (f_dest), opval);
3866 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3867 
  }
3868 
}
3869 
 
3870 
  return vpc;
3871 
#undef FLD
3872 
}
3873 
 
3874 
/* mshardl: mshard.l $rm, $rn, $rd */
3875 
 
3876 
static SEM_PC
3877 
SEM_FN_NAME (sh64_media,mshardl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3878 
{
3879 
#define FLD(f) abuf->fields.sfmt_add.f
3880 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3881 
  int UNUSED written = 0;
3882 
  IADDR UNUSED pc = abuf->addr;
3883 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3884 
 
3885 
{
3886 
  SI tmp_result1;
3887 
  SI tmp_result0;
3888 
  tmp_result0 = SRASI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 31));
3889 
  tmp_result1 = SRASI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), ANDDI (GET_H_GR (FLD (f_right)), 31));
3890 
  {
3891 
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
3892 
    SET_H_GR (FLD (f_dest), opval);
3893 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3894 
  }
3895 
}
3896 
 
3897 
  return vpc;
3898 
#undef FLD
3899 
}
3900 
 
3901 
/* mshardw: mshard.w $rm, $rn, $rd */
3902 
 
3903 
static SEM_PC
3904 
SEM_FN_NAME (sh64_media,mshardw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3905 
{
3906 
#define FLD(f) abuf->fields.sfmt_add.f
3907 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3908 
  int UNUSED written = 0;
3909 
  IADDR UNUSED pc = abuf->addr;
3910 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3911 
 
3912 
{
3913 
  HI tmp_result3;
3914 
  HI tmp_result2;
3915 
  HI tmp_result1;
3916 
  HI tmp_result0;
3917 
  tmp_result0 = SRAHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), ANDDI (GET_H_GR (FLD (f_right)), 15));
3918 
  tmp_result1 = SRAHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), ANDDI (GET_H_GR (FLD (f_right)), 15));
3919 
  tmp_result2 = SRAHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 15));
3920 
  tmp_result3 = SRAHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), ANDDI (GET_H_GR (FLD (f_right)), 15));
3921 
  {
3922 
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
3923 
    SET_H_GR (FLD (f_dest), opval);
3924 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3925 
  }
3926 
}
3927 
 
3928 
  return vpc;
3929 
#undef FLD
3930 
}
3931 
 
3932 
/* mshardsq: mshards.q $rm, $rn, $rd */
3933 
 
3934 
static SEM_PC
3935 
SEM_FN_NAME (sh64_media,mshardsq) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3936 
{
3937 
#define FLD(f) abuf->fields.sfmt_add.f
3938 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3939 
  int UNUSED written = 0;
3940 
  IADDR UNUSED pc = abuf->addr;
3941 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3942 
 
3943 
  {
3944 
    DI opval = ((LTDI (SRADI (GET_H_GR (FLD (f_left)), ANDDI (GET_H_GR (FLD (f_right)), 63)), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGDI (SLLDI (1, SUBSI (16, 1)))) : (((LTDI (SRADI (GET_H_GR (FLD (f_left)), ANDDI (GET_H_GR (FLD (f_right)), 63)), SLLDI (1, SUBSI (16, 1)))) ? (SRADI (GET_H_GR (FLD (f_left)), ANDDI (GET_H_GR (FLD (f_right)), 63))) : (SUBDI (SLLDI (1, SUBSI (16, 1)), 1)))));
3945 
    SET_H_GR (FLD (f_dest), opval);
3946 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3947 
  }
3948 
 
3949 
  return vpc;
3950 
#undef FLD
3951 
}
3952 
 
3953 
/* mshfhib: mshfhi.b $rm, $rn, $rd */
3954 
 
3955 
static SEM_PC
3956 
SEM_FN_NAME (sh64_media,mshfhib) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3957 
{
3958 
#define FLD(f) abuf->fields.sfmt_add.f
3959 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3960 
  int UNUSED written = 0;
3961 
  IADDR UNUSED pc = abuf->addr;
3962 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3963 
 
3964 
{
3965 
  QI tmp_result7;
3966 
  QI tmp_result6;
3967 
  QI tmp_result5;
3968 
  QI tmp_result4;
3969 
  QI tmp_result3;
3970 
  QI tmp_result2;
3971 
  QI tmp_result1;
3972 
  QI tmp_result0;
3973 
  tmp_result0 = SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3);
3974 
  tmp_result1 = SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3);
3975 
  tmp_result2 = SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2);
3976 
  tmp_result3 = SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2);
3977 
  tmp_result4 = SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1);
3978 
  tmp_result5 = SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1);
3979 
  tmp_result6 = SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0);
3980 
  tmp_result7 = SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0);
3981 
  {
3982 
    DI opval = ORDI (SLLDI (ZEXTQIDI (tmp_result7), 56), ORDI (SLLDI (ZEXTQIDI (tmp_result6), 48), ORDI (SLLDI (ZEXTQIDI (tmp_result5), 40), ORDI (SLLDI (ZEXTQIDI (tmp_result4), 32), ORDI (SLLDI (ZEXTQIDI (tmp_result3), 24), ORDI (SLLDI (ZEXTQIDI (tmp_result2), 16), ORDI (SLLDI (ZEXTQIDI (tmp_result1), 8), ZEXTQIDI (tmp_result0))))))));
3983 
    SET_H_GR (FLD (f_dest), opval);
3984 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3985 
  }
3986 
}
3987 
 
3988 
  return vpc;
3989 
#undef FLD
3990 
}
3991 
 
3992 
/* mshfhil: mshfhi.l $rm, $rn, $rd */
3993 
 
3994 
static SEM_PC
3995 
SEM_FN_NAME (sh64_media,mshfhil) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3996 
{
3997 
#define FLD(f) abuf->fields.sfmt_add.f
3998 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3999 
  int UNUSED written = 0;
4000 
  IADDR UNUSED pc = abuf->addr;
4001 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4002 
 
4003 
{
4004 
  SI tmp_result1;
4005 
  SI tmp_result0;
4006 
  tmp_result0 = SUBWORDDISI (GET_H_GR (FLD (f_left)), 0);
4007 
  tmp_result1 = SUBWORDDISI (GET_H_GR (FLD (f_right)), 0);
4008 
  {
4009 
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
4010 
    SET_H_GR (FLD (f_dest), opval);
4011 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4012 
  }
4013 
}
4014 
 
4015 
  return vpc;
4016 
#undef FLD
4017 
}
4018 
 
4019 
/* mshfhiw: mshfhi.w $rm, $rn, $rd */
4020 
 
4021 
static SEM_PC
4022 
SEM_FN_NAME (sh64_media,mshfhiw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4023 
{
4024 
#define FLD(f) abuf->fields.sfmt_add.f
4025 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4026 
  int UNUSED written = 0;
4027 
  IADDR UNUSED pc = abuf->addr;
4028 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4029 
 
4030 
{
4031 
  HI tmp_result3;
4032 
  HI tmp_result2;
4033 
  HI tmp_result1;
4034 
  HI tmp_result0;
4035 
  tmp_result0 = SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1);
4036 
  tmp_result1 = SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1);
4037 
  tmp_result2 = SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0);
4038 
  tmp_result3 = SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0);
4039 
  {
4040 
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
4041 
    SET_H_GR (FLD (f_dest), opval);
4042 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4043 
  }
4044 
}
4045 
 
4046 
  return vpc;
4047 
#undef FLD
4048 
}
4049 
 
4050 
/* mshflob: mshflo.b $rm, $rn, $rd */
4051 
 
4052 
static SEM_PC
4053 
SEM_FN_NAME (sh64_media,mshflob) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4054 
{
4055 
#define FLD(f) abuf->fields.sfmt_add.f
4056 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4057 
  int UNUSED written = 0;
4058 
  IADDR UNUSED pc = abuf->addr;
4059 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4060 
 
4061 
{
4062 
  QI tmp_result7;
4063 
  QI tmp_result6;
4064 
  QI tmp_result5;
4065 
  QI tmp_result4;
4066 
  QI tmp_result3;
4067 
  QI tmp_result2;
4068 
  QI tmp_result1;
4069 
  QI tmp_result0;
4070 
  tmp_result0 = SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7);
4071 
  tmp_result1 = SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7);
4072 
  tmp_result2 = SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6);
4073 
  tmp_result3 = SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6);
4074 
  tmp_result4 = SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5);
4075 
  tmp_result5 = SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5);
4076 
  tmp_result6 = SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4);
4077 
  tmp_result7 = SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4);
4078 
  {
4079 
    DI opval = ORDI (SLLDI (ZEXTQIDI (tmp_result7), 56), ORDI (SLLDI (ZEXTQIDI (tmp_result6), 48), ORDI (SLLDI (ZEXTQIDI (tmp_result5), 40), ORDI (SLLDI (ZEXTQIDI (tmp_result4), 32), ORDI (SLLDI (ZEXTQIDI (tmp_result3), 24), ORDI (SLLDI (ZEXTQIDI (tmp_result2), 16), ORDI (SLLDI (ZEXTQIDI (tmp_result1), 8), ZEXTQIDI (tmp_result0))))))));
4080 
    SET_H_GR (FLD (f_dest), opval);
4081 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4082 
  }
4083 
}
4084 
 
4085 
  return vpc;
4086 
#undef FLD
4087 
}
4088 
 
4089 
/* mshflol: mshflo.l $rm, $rn, $rd */
4090 
 
4091 
static SEM_PC
4092 
SEM_FN_NAME (sh64_media,mshflol) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4093 
{
4094 
#define FLD(f) abuf->fields.sfmt_add.f
4095 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4096 
  int UNUSED written = 0;
4097 
  IADDR UNUSED pc = abuf->addr;
4098 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4099 
 
4100 
{
4101 
  SI tmp_result1;
4102 
  SI tmp_result0;
4103 
  tmp_result0 = SUBWORDDISI (GET_H_GR (FLD (f_left)), 1);
4104 
  tmp_result1 = SUBWORDDISI (GET_H_GR (FLD (f_right)), 1);
4105 
  {
4106 
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
4107 
    SET_H_GR (FLD (f_dest), opval);
4108 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4109 
  }
4110 
}
4111 
 
4112 
  return vpc;
4113 
#undef FLD
4114 
}
4115 
 
4116 
/* mshflow: mshflo.w $rm, $rn, $rd */
4117 
 
4118 
static SEM_PC
4119 
SEM_FN_NAME (sh64_media,mshflow) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4120 
{
4121 
#define FLD(f) abuf->fields.sfmt_add.f
4122 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4123 
  int UNUSED written = 0;
4124 
  IADDR UNUSED pc = abuf->addr;
4125 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4126 
 
4127 
{
4128 
  HI tmp_result3;
4129 
  HI tmp_result2;
4130 
  HI tmp_result1;
4131 
  HI tmp_result0;
4132 
  tmp_result0 = SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3);
4133 
  tmp_result1 = SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3);
4134 
  tmp_result2 = SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2);
4135 
  tmp_result3 = SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2);
4136 
  {
4137 
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
4138 
    SET_H_GR (FLD (f_dest), opval);
4139 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4140 
  }
4141 
}
4142 
 
4143 
  return vpc;
4144 
#undef FLD
4145 
}
4146 
 
4147 
/* mshlldl: mshlld.l $rm, $rn, $rd */
4148 
 
4149 
static SEM_PC
4150 
SEM_FN_NAME (sh64_media,mshlldl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4151 
{
4152 
#define FLD(f) abuf->fields.sfmt_add.f
4153 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4154 
  int UNUSED written = 0;
4155 
  IADDR UNUSED pc = abuf->addr;
4156 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4157 
 
4158 
{
4159 
  SI tmp_result1;
4160 
  SI tmp_result0;
4161 
  tmp_result0 = SLLSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 31));
4162 
  tmp_result1 = SLLSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), ANDDI (GET_H_GR (FLD (f_right)), 31));
4163 
  {
4164 
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
4165 
    SET_H_GR (FLD (f_dest), opval);
4166 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4167 
  }
4168 
}
4169 
 
4170 
  return vpc;
4171 
#undef FLD
4172 
}
4173 
 
4174 
/* mshlldw: mshlld.w $rm, $rn, $rd */
4175 
 
4176 
static SEM_PC
4177 
SEM_FN_NAME (sh64_media,mshlldw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4178 
{
4179 
#define FLD(f) abuf->fields.sfmt_add.f
4180 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4181 
  int UNUSED written = 0;
4182 
  IADDR UNUSED pc = abuf->addr;
4183 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4184 
 
4185 
{
4186 
  HI tmp_result3;
4187 
  HI tmp_result2;
4188 
  HI tmp_result1;
4189 
  HI tmp_result0;
4190 
  tmp_result0 = SLLHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), ANDDI (GET_H_GR (FLD (f_right)), 15));
4191 
  tmp_result1 = SLLHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), ANDDI (GET_H_GR (FLD (f_right)), 15));
4192 
  tmp_result2 = SLLHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 15));
4193 
  tmp_result3 = SLLHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), ANDDI (GET_H_GR (FLD (f_right)), 15));
4194 
  {
4195 
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
4196 
    SET_H_GR (FLD (f_dest), opval);
4197 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4198 
  }
4199 
}
4200 
 
4201 
  return vpc;
4202 
#undef FLD
4203 
}
4204 
 
4205 
/* mshlrdl: mshlrd.l $rm, $rn, $rd */
4206 
 
4207 
static SEM_PC
4208 
SEM_FN_NAME (sh64_media,mshlrdl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4209 
{
4210 
#define FLD(f) abuf->fields.sfmt_add.f
4211 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4212 
  int UNUSED written = 0;
4213 
  IADDR UNUSED pc = abuf->addr;
4214 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4215 
 
4216 
{
4217 
  SI tmp_result1;
4218 
  SI tmp_result0;
4219 
  tmp_result0 = SRLSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 31));
4220 
  tmp_result1 = SRLSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), ANDDI (GET_H_GR (FLD (f_right)), 31));
4221 
  {
4222 
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
4223 
    SET_H_GR (FLD (f_dest), opval);
4224 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4225 
  }
4226 
}
4227 
 
4228 
  return vpc;
4229 
#undef FLD
4230 
}
4231 
 
4232 
/* mshlrdw: mshlrd.w $rm, $rn, $rd */
4233 
 
4234 
static SEM_PC
4235 
SEM_FN_NAME (sh64_media,mshlrdw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4236 
{
4237 
#define FLD(f) abuf->fields.sfmt_add.f
4238 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4239 
  int UNUSED written = 0;
4240 
  IADDR UNUSED pc = abuf->addr;
4241 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4242 
 
4243 
{
4244 
  HI tmp_result3;
4245 
  HI tmp_result2;
4246 
  HI tmp_result1;
4247 
  HI tmp_result0;
4248 
  tmp_result0 = SRLHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), ANDDI (GET_H_GR (FLD (f_right)), 15));
4249 
  tmp_result1 = SRLHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), ANDDI (GET_H_GR (FLD (f_right)), 15));
4250 
  tmp_result2 = SRLHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 15));
4251 
  tmp_result3 = SRLHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), ANDDI (GET_H_GR (FLD (f_right)), 15));
4252 
  {
4253 
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
4254 
    SET_H_GR (FLD (f_dest), opval);
4255 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4256 
  }
4257 
}
4258 
 
4259 
  return vpc;
4260 
#undef FLD
4261 
}
4262 
 
4263 
/* msubl: msub.l $rm, $rn, $rd */
4264 
 
4265 
static SEM_PC
4266 
SEM_FN_NAME (sh64_media,msubl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4267 
{
4268 
#define FLD(f) abuf->fields.sfmt_add.f
4269 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4270 
  int UNUSED written = 0;
4271 
  IADDR UNUSED pc = abuf->addr;
4272 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4273 
 
4274 
{
4275 
  SI tmp_result1;
4276 
  SI tmp_result0;
4277 
  tmp_result0 = SUBSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), SUBWORDDISI (GET_H_GR (FLD (f_right)), 1));
4278 
  tmp_result1 = SUBSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), SUBWORDDISI (GET_H_GR (FLD (f_right)), 0));
4279 
  {
4280 
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
4281 
    SET_H_GR (FLD (f_dest), opval);
4282 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4283 
  }
4284 
}
4285 
 
4286 
  return vpc;
4287 
#undef FLD
4288 
}
4289 
 
4290 
/* msubw: msub.w $rm, $rn, $rd */
4291 
 
4292 
static SEM_PC
4293 
SEM_FN_NAME (sh64_media,msubw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4294 
{
4295 
#define FLD(f) abuf->fields.sfmt_add.f
4296 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4297 
  int UNUSED written = 0;
4298 
  IADDR UNUSED pc = abuf->addr;
4299 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4300 
 
4301 
{
4302 
  HI tmp_result3;
4303 
  HI tmp_result2;
4304 
  HI tmp_result1;
4305 
  HI tmp_result0;
4306 
  tmp_result0 = SUBHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3));
4307 
  tmp_result1 = SUBHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2));
4308 
  tmp_result2 = SUBHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1));
4309 
  tmp_result3 = SUBHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0));
4310 
  {
4311 
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
4312 
    SET_H_GR (FLD (f_dest), opval);
4313 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4314 
  }
4315 
}
4316 
 
4317 
  return vpc;
4318 
#undef FLD
4319 
}
4320 
 
4321 
/* msubsl: msubs.l $rm, $rn, $rd */
4322 
 
4323 
static SEM_PC
4324 
SEM_FN_NAME (sh64_media,msubsl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4325 
{
4326 
#define FLD(f) abuf->fields.sfmt_add.f
4327 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4328 
  int UNUSED written = 0;
4329 
  IADDR UNUSED pc = abuf->addr;
4330 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4331 
 
4332 
{
4333 
  SI tmp_result1;
4334 
  SI tmp_result0;
4335 
  tmp_result0 = ((LTDI (SUBDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 1))), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (SUBDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 1))), SLLDI (1, SUBSI (32, 1)))) ? (SUBDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 1)))) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
4336 
  tmp_result1 = ((LTDI (SUBDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 0))), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (SUBDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 0))), SLLDI (1, SUBSI (32, 1)))) ? (SUBDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 0)))) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
4337 
  {
4338 
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
4339 
    SET_H_GR (FLD (f_dest), opval);
4340 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4341 
  }
4342 
}
4343 
 
4344 
  return vpc;
4345 
#undef FLD
4346 
}
4347 
 
4348 
/* msubsub: msubs.ub $rm, $rn, $rd */
4349 
 
4350 
static SEM_PC
4351 
SEM_FN_NAME (sh64_media,msubsub) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4352 
{
4353 
#define FLD(f) abuf->fields.sfmt_add.f
4354 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4355 
  int UNUSED written = 0;
4356 
  IADDR UNUSED pc = abuf->addr;
4357 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4358 
 
4359 
{
4360 
  QI tmp_result7;
4361 
  QI tmp_result6;
4362 
  QI tmp_result5;
4363 
  QI tmp_result4;
4364 
  QI tmp_result3;
4365 
  QI tmp_result2;
4366 
  QI tmp_result1;
4367 
  QI tmp_result0;
4368 
  tmp_result0 = ((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7))), MAKEDI (0, 0))) ? (0) : (((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7))), SLLDI (1, 8))) ? (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7)))) : (SUBQI (SLLQI (1, 8), 1)))));
4369 
  tmp_result1 = ((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6))), MAKEDI (0, 0))) ? (0) : (((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6))), SLLDI (1, 8))) ? (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6)))) : (SUBQI (SLLQI (1, 8), 1)))));
4370 
  tmp_result2 = ((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5))), MAKEDI (0, 0))) ? (0) : (((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5))), SLLDI (1, 8))) ? (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5)))) : (SUBQI (SLLQI (1, 8), 1)))));
4371 
  tmp_result3 = ((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4))), MAKEDI (0, 0))) ? (0) : (((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4))), SLLDI (1, 8))) ? (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4)))) : (SUBQI (SLLQI (1, 8), 1)))));
4372 
  tmp_result4 = ((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3))), MAKEDI (0, 0))) ? (0) : (((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3))), SLLDI (1, 8))) ? (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3)))) : (SUBQI (SLLQI (1, 8), 1)))));
4373 
  tmp_result5 = ((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2))), MAKEDI (0, 0))) ? (0) : (((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2))), SLLDI (1, 8))) ? (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2)))) : (SUBQI (SLLQI (1, 8), 1)))));
4374 
  tmp_result6 = ((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1))), MAKEDI (0, 0))) ? (0) : (((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1))), SLLDI (1, 8))) ? (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1)))) : (SUBQI (SLLQI (1, 8), 1)))));
4375 
  tmp_result7 = ((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0))), MAKEDI (0, 0))) ? (0) : (((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0))), SLLDI (1, 8))) ? (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0)))) : (SUBQI (SLLQI (1, 8), 1)))));
4376 
  {
4377 
    DI opval = ORDI (SLLDI (ZEXTQIDI (tmp_result7), 56), ORDI (SLLDI (ZEXTQIDI (tmp_result6), 48), ORDI (SLLDI (ZEXTQIDI (tmp_result5), 40), ORDI (SLLDI (ZEXTQIDI (tmp_result4), 32), ORDI (SLLDI (ZEXTQIDI (tmp_result3), 24), ORDI (SLLDI (ZEXTQIDI (tmp_result2), 16), ORDI (SLLDI (ZEXTQIDI (tmp_result1), 8), ZEXTQIDI (tmp_result0))))))));
4378 
    SET_H_GR (FLD (f_dest), opval);
4379 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4380 
  }
4381 
}
4382 
 
4383 
  return vpc;
4384 
#undef FLD
4385 
}
4386 
 
4387 
/* msubsw: msubs.w $rm, $rn, $rd */
4388 
 
4389 
static SEM_PC
4390 
SEM_FN_NAME (sh64_media,msubsw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4391 
{
4392 
#define FLD(f) abuf->fields.sfmt_add.f
4393 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4394 
  int UNUSED written = 0;
4395 
  IADDR UNUSED pc = abuf->addr;
4396 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4397 
 
4398 
{
4399 
  QI tmp_result7;
4400 
  QI tmp_result6;
4401 
  QI tmp_result5;
4402 
  QI tmp_result4;
4403 
  QI tmp_result3;
4404 
  QI tmp_result2;
4405 
  QI tmp_result1;
4406 
  QI tmp_result0;
4407 
  tmp_result0 = ((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7))), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7))), SLLDI (1, SUBSI (16, 1)))) ? (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7)))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
4408 
  tmp_result1 = ((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6))), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6))), SLLDI (1, SUBSI (16, 1)))) ? (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6)))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
4409 
  tmp_result2 = ((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5))), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5))), SLLDI (1, SUBSI (16, 1)))) ? (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5)))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
4410 
  tmp_result3 = ((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4))), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4))), SLLDI (1, SUBSI (16, 1)))) ? (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4)))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
4411 
  tmp_result4 = ((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3))), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3))), SLLDI (1, SUBSI (16, 1)))) ? (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3)))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
4412 
  tmp_result5 = ((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2))), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2))), SLLDI (1, SUBSI (16, 1)))) ? (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2)))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
4413 
  tmp_result6 = ((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1))), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1))), SLLDI (1, SUBSI (16, 1)))) ? (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1)))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
4414 
  tmp_result7 = ((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0))), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0))), SLLDI (1, SUBSI (16, 1)))) ? (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0)))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
4415 
  {
4416 
    DI opval = ORDI (SLLDI (ZEXTQIDI (tmp_result7), 56), ORDI (SLLDI (ZEXTQIDI (tmp_result6), 48), ORDI (SLLDI (ZEXTQIDI (tmp_result5), 40), ORDI (SLLDI (ZEXTQIDI (tmp_result4), 32), ORDI (SLLDI (ZEXTQIDI (tmp_result3), 24), ORDI (SLLDI (ZEXTQIDI (tmp_result2), 16), ORDI (SLLDI (ZEXTQIDI (tmp_result1), 8), ZEXTQIDI (tmp_result0))))))));
4417 
    SET_H_GR (FLD (f_dest), opval);
4418 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4419 
  }
4420 
}
4421 
 
4422 
  return vpc;
4423 
#undef FLD
4424 
}
4425 
 
4426 
/* mulsl: muls.l $rm, $rn, $rd */
4427 
 
4428 
static SEM_PC
4429 
SEM_FN_NAME (sh64_media,mulsl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4430 
{
4431 
#define FLD(f) abuf->fields.sfmt_add.f
4432 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4433 
  int UNUSED written = 0;
4434 
  IADDR UNUSED pc = abuf->addr;
4435 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4436 
 
4437 
  {
4438 
    DI opval = MULDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 1)));
4439 
    SET_H_GR (FLD (f_dest), opval);
4440 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4441 
  }
4442 
 
4443 
  return vpc;
4444 
#undef FLD
4445 
}
4446 
 
4447 
/* mulul: mulu.l $rm, $rn, $rd */
4448 
 
4449 
static SEM_PC
4450 
SEM_FN_NAME (sh64_media,mulul) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4451 
{
4452 
#define FLD(f) abuf->fields.sfmt_add.f
4453 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4454 
  int UNUSED written = 0;
4455 
  IADDR UNUSED pc = abuf->addr;
4456 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4457 
 
4458 
  {
4459 
    DI opval = MULDI (ZEXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1)), ZEXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 1)));
4460 
    SET_H_GR (FLD (f_dest), opval);
4461 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4462 
  }
4463 
 
4464 
  return vpc;
4465 
#undef FLD
4466 
}
4467 
 
4468 
/* nop: nop */
4469 
 
4470 
static SEM_PC
4471 
SEM_FN_NAME (sh64_media,nop) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4472 
{
4473 
#define FLD(f) abuf->fields.sfmt_empty.f
4474 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4475 
  int UNUSED written = 0;
4476 
  IADDR UNUSED pc = abuf->addr;
4477 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4478 
 
4479 
((void) 0); /*nop*/
4480 
 
4481 
  return vpc;
4482 
#undef FLD
4483 
}
4484 
 
4485 
/* nsb: nsb $rm, $rd */
4486 
 
4487 
static SEM_PC
4488 
SEM_FN_NAME (sh64_media,nsb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4489 
{
4490 
#define FLD(f) abuf->fields.sfmt_xori.f
4491 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4492 
  int UNUSED written = 0;
4493 
  IADDR UNUSED pc = abuf->addr;
4494 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4495 
 
4496 
  {
4497 
    DI opval = sh64_nsb (current_cpu, GET_H_GR (FLD (f_left)));
4498 
    SET_H_GR (FLD (f_dest), opval);
4499 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4500 
  }
4501 
 
4502 
  return vpc;
4503 
#undef FLD
4504 
}
4505 
 
4506 
/* ocbi: ocbi $rm, $disp6x32 */
4507 
 
4508 
static SEM_PC
4509 
SEM_FN_NAME (sh64_media,ocbi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4510 
{
4511 
#define FLD(f) abuf->fields.sfmt_xori.f
4512 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4513 
  int UNUSED written = 0;
4514 
  IADDR UNUSED pc = abuf->addr;
4515 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4516 
 
4517 
{
4518 
  {
4519 
    DI opval = GET_H_GR (FLD (f_left));
4520 
    SET_H_GR (FLD (f_left), opval);
4521 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4522 
  }
4523 
((void) 0); /*nop*/
4524 
}
4525 
 
4526 
  return vpc;
4527 
#undef FLD
4528 
}
4529 
 
4530 
/* ocbp: ocbp $rm, $disp6x32 */
4531 
 
4532 
static SEM_PC
4533 
SEM_FN_NAME (sh64_media,ocbp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4534 
{
4535 
#define FLD(f) abuf->fields.sfmt_xori.f
4536 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4537 
  int UNUSED written = 0;
4538 
  IADDR UNUSED pc = abuf->addr;
4539 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4540 
 
4541 
{
4542 
  {
4543 
    DI opval = GET_H_GR (FLD (f_left));
4544 
    SET_H_GR (FLD (f_left), opval);
4545 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4546 
  }
4547 
((void) 0); /*nop*/
4548 
}
4549 
 
4550 
  return vpc;
4551 
#undef FLD
4552 
}
4553 
 
4554 
/* ocbwb: ocbwb $rm, $disp6x32 */
4555 
 
4556 
static SEM_PC
4557 
SEM_FN_NAME (sh64_media,ocbwb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4558 
{
4559 
#define FLD(f) abuf->fields.sfmt_xori.f
4560 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4561 
  int UNUSED written = 0;
4562 
  IADDR UNUSED pc = abuf->addr;
4563 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4564 
 
4565 
{
4566 
  {
4567 
    DI opval = GET_H_GR (FLD (f_left));
4568 
    SET_H_GR (FLD (f_left), opval);
4569 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4570 
  }
4571 
((void) 0); /*nop*/
4572 
}
4573 
 
4574 
  return vpc;
4575 
#undef FLD
4576 
}
4577 
 
4578 
/* or: or $rm, $rn, $rd */
4579 
 
4580 
static SEM_PC
4581 
SEM_FN_NAME (sh64_media,or) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4582 
{
4583 
#define FLD(f) abuf->fields.sfmt_add.f
4584 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4585 
  int UNUSED written = 0;
4586 
  IADDR UNUSED pc = abuf->addr;
4587 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4588 
 
4589 
  {
4590 
    DI opval = ORDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)));
4591 
    SET_H_GR (FLD (f_dest), opval);
4592 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4593 
  }
4594 
 
4595 
  return vpc;
4596 
#undef FLD
4597 
}
4598 
 
4599 
/* ori: ori $rm, $imm10, $rd */
4600 
 
4601 
static SEM_PC
4602 
SEM_FN_NAME (sh64_media,ori) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4603 
{
4604 
#define FLD(f) abuf->fields.sfmt_ori.f
4605 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4606 
  int UNUSED written = 0;
4607 
  IADDR UNUSED pc = abuf->addr;
4608 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4609 
 
4610 
  {
4611 
    DI opval = ORDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_imm10)));
4612 
    SET_H_GR (FLD (f_dest), opval);
4613 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4614 
  }
4615 
 
4616 
  return vpc;
4617 
#undef FLD
4618 
}
4619 
 
4620 
/* prefi: prefi $rm, $disp6x32 */
4621 
 
4622 
static SEM_PC
4623 
SEM_FN_NAME (sh64_media,prefi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4624 
{
4625 
#define FLD(f) abuf->fields.sfmt_xori.f
4626 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4627 
  int UNUSED written = 0;
4628 
  IADDR UNUSED pc = abuf->addr;
4629 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4630 
 
4631 
{
4632 
  {
4633 
    DI opval = GET_H_GR (FLD (f_left));
4634 
    SET_H_GR (FLD (f_left), opval);
4635 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4636 
  }
4637 
((void) 0); /*nop*/
4638 
}
4639 
 
4640 
  return vpc;
4641 
#undef FLD
4642 
}
4643 
 
4644 
/* pta: pta$likely $disp16, $tra */
4645 
 
4646 
static SEM_PC
4647 
SEM_FN_NAME (sh64_media,pta) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4648 
{
4649 
#define FLD(f) abuf->fields.sfmt_pta.f
4650 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4651 
  int UNUSED written = 0;
4652 
  IADDR UNUSED pc = abuf->addr;
4653 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4654 
 
4655 
{
4656 
((void) 0); /*nop*/
4657 
  {
4658 
    DI opval = ADDSI (FLD (f_disp16), 1);
4659 
    CPU (h_tr[FLD (f_tra)]) = opval;
4660 
    TRACE_RESULT (current_cpu, abuf, "tr", 'D', opval);
4661 
  }
4662 
}
4663 
 
4664 
  return vpc;
4665 
#undef FLD
4666 
}
4667 
 
4668 
/* ptabs: ptabs$likely $rn, $tra */
4669 
 
4670 
static SEM_PC
4671 
SEM_FN_NAME (sh64_media,ptabs) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4672 
{
4673 
#define FLD(f) abuf->fields.sfmt_beq.f
4674 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4675 
  int UNUSED written = 0;
4676 
  IADDR UNUSED pc = abuf->addr;
4677 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4678 
 
4679 
{
4680 
((void) 0); /*nop*/
4681 
  {
4682 
    DI opval = GET_H_GR (FLD (f_right));
4683 
    CPU (h_tr[FLD (f_tra)]) = opval;
4684 
    TRACE_RESULT (current_cpu, abuf, "tr", 'D', opval);
4685 
  }
4686 
}
4687 
 
4688 
  return vpc;
4689 
#undef FLD
4690 
}
4691 
 
4692 
/* ptb: ptb$likely $disp16, $tra */
4693 
 
4694 
static SEM_PC
4695 
SEM_FN_NAME (sh64_media,ptb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4696 
{
4697 
#define FLD(f) abuf->fields.sfmt_pta.f
4698 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4699 
  int UNUSED written = 0;
4700 
  IADDR UNUSED pc = abuf->addr;
4701 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4702 
 
4703 
{
4704 
((void) 0); /*nop*/
4705 
  {
4706 
    DI opval = FLD (f_disp16);
4707 
    CPU (h_tr[FLD (f_tra)]) = opval;
4708 
    TRACE_RESULT (current_cpu, abuf, "tr", 'D', opval);
4709 
  }
4710 
}
4711 
 
4712 
  return vpc;
4713 
#undef FLD
4714 
}
4715 
 
4716 
/* ptrel: ptrel$likely $rn, $tra */
4717 
 
4718 
static SEM_PC
4719 
SEM_FN_NAME (sh64_media,ptrel) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4720 
{
4721 
#define FLD(f) abuf->fields.sfmt_beq.f
4722 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4723 
  int UNUSED written = 0;
4724 
  IADDR UNUSED pc = abuf->addr;
4725 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4726 
 
4727 
{
4728 
((void) 0); /*nop*/
4729 
  {
4730 
    DI opval = ADDDI (pc, GET_H_GR (FLD (f_right)));
4731 
    CPU (h_tr[FLD (f_tra)]) = opval;
4732 
    TRACE_RESULT (current_cpu, abuf, "tr", 'D', opval);
4733 
  }
4734 
}
4735 
 
4736 
  return vpc;
4737 
#undef FLD
4738 
}
4739 
 
4740 
/* putcfg: putcfg $rm, $disp6, $rd */
4741 
 
4742 
static SEM_PC
4743 
SEM_FN_NAME (sh64_media,putcfg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4744 
{
4745 
#define FLD(f) abuf->fields.sfmt_getcfg.f
4746 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4747 
  int UNUSED written = 0;
4748 
  IADDR UNUSED pc = abuf->addr;
4749 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4750 
 
4751 
{
4752 
  SI tmp_address;
4753 
  tmp_address = ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp6));
4754 
((void) 0); /*nop*/
4755 
  {
4756 
    SI opval = GET_H_GR (FLD (f_dest));
4757 
    SETMEMSI (current_cpu, pc, tmp_address, opval);
4758 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4759 
  }
4760 
}
4761 
 
4762 
  return vpc;
4763 
#undef FLD
4764 
}
4765 
 
4766 
/* putcon: putcon $rm, $crj */
4767 
 
4768 
static SEM_PC
4769 
SEM_FN_NAME (sh64_media,putcon) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4770 
{
4771 
#define FLD(f) abuf->fields.sfmt_xori.f
4772 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4773 
  int UNUSED written = 0;
4774 
  IADDR UNUSED pc = abuf->addr;
4775 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4776 
 
4777 
  {
4778 
    DI opval = GET_H_GR (FLD (f_left));
4779 
    SET_H_CR (FLD (f_dest), opval);
4780 
    TRACE_RESULT (current_cpu, abuf, "cr", 'D', opval);
4781 
  }
4782 
 
4783 
  return vpc;
4784 
#undef FLD
4785 
}
4786 
 
4787 
/* rte: rte */
4788 
 
4789 
static SEM_PC
4790 
SEM_FN_NAME (sh64_media,rte) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4791 
{
4792 
#define FLD(f) abuf->fields.sfmt_empty.f
4793 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4794 
  int UNUSED written = 0;
4795 
  IADDR UNUSED pc = abuf->addr;
4796 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4797 
 
4798 
((void) 0); /*nop*/
4799 
 
4800 
  return vpc;
4801 
#undef FLD
4802 
}
4803 
 
4804 
/* shard: shard $rm, $rn, $rd */
4805 
 
4806 
static SEM_PC
4807 
SEM_FN_NAME (sh64_media,shard) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4808 
{
4809 
#define FLD(f) abuf->fields.sfmt_add.f
4810 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4811 
  int UNUSED written = 0;
4812 
  IADDR UNUSED pc = abuf->addr;
4813 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4814 
 
4815 
  {
4816 
    DI opval = SRADI (GET_H_GR (FLD (f_left)), ANDDI (GET_H_GR (FLD (f_right)), 63));
4817 
    SET_H_GR (FLD (f_dest), opval);
4818 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4819 
  }
4820 
 
4821 
  return vpc;
4822 
#undef FLD
4823 
}
4824 
 
4825 
/* shardl: shard.l $rm, $rn, $rd */
4826 
 
4827 
static SEM_PC
4828 
SEM_FN_NAME (sh64_media,shardl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4829 
{
4830 
#define FLD(f) abuf->fields.sfmt_add.f
4831 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4832 
  int UNUSED written = 0;
4833 
  IADDR UNUSED pc = abuf->addr;
4834 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4835 
 
4836 
  {
4837 
    DI opval = EXTSIDI (SRASI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 63)));
4838 
    SET_H_GR (FLD (f_dest), opval);
4839 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4840 
  }
4841 
 
4842 
  return vpc;
4843 
#undef FLD
4844 
}
4845 
 
4846 
/* shari: shari $rm, $uimm6, $rd */
4847 
 
4848 
static SEM_PC
4849 
SEM_FN_NAME (sh64_media,shari) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4850 
{
4851 
#define FLD(f) abuf->fields.sfmt_shari.f
4852 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4853 
  int UNUSED written = 0;
4854 
  IADDR UNUSED pc = abuf->addr;
4855 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4856 
 
4857 
  {
4858 
    DI opval = SRADI (GET_H_GR (FLD (f_left)), FLD (f_uimm6));
4859 
    SET_H_GR (FLD (f_dest), opval);
4860 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4861 
  }
4862 
 
4863 
  return vpc;
4864 
#undef FLD
4865 
}
4866 
 
4867 
/* sharil: shari.l $rm, $uimm6, $rd */
4868 
 
4869 
static SEM_PC
4870 
SEM_FN_NAME (sh64_media,sharil) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4871 
{
4872 
#define FLD(f) abuf->fields.sfmt_shari.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, 4);
4877 
 
4878 
  {
4879 
    DI opval = EXTSIDI (SRASI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), ANDSI (FLD (f_uimm6), 63)));
4880 
    SET_H_GR (FLD (f_dest), opval);
4881 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4882 
  }
4883 
 
4884 
  return vpc;
4885 
#undef FLD
4886 
}
4887 
 
4888 
/* shlld: shlld $rm, $rn, $rd */
4889 
 
4890 
static SEM_PC
4891 
SEM_FN_NAME (sh64_media,shlld) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4892 
{
4893 
#define FLD(f) abuf->fields.sfmt_add.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, 4);
4898 
 
4899 
  {
4900 
    DI opval = SLLDI (GET_H_GR (FLD (f_left)), ANDDI (GET_H_GR (FLD (f_right)), 63));
4901 
    SET_H_GR (FLD (f_dest), opval);
4902 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4903 
  }
4904 
 
4905 
  return vpc;
4906 
#undef FLD
4907 
}
4908 
 
4909 
/* shlldl: shlld.l $rm, $rn, $rd */
4910 
 
4911 
static SEM_PC
4912 
SEM_FN_NAME (sh64_media,shlldl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4913 
{
4914 
#define FLD(f) abuf->fields.sfmt_add.f
4915 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4916 
  int UNUSED written = 0;
4917 
  IADDR UNUSED pc = abuf->addr;
4918 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4919 
 
4920 
  {
4921 
    DI opval = EXTSIDI (SLLSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 63)));
4922 
    SET_H_GR (FLD (f_dest), opval);
4923 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4924 
  }
4925 
 
4926 
  return vpc;
4927 
#undef FLD
4928 
}
4929 
 
4930 
/* shlli: shlli $rm, $uimm6, $rd */
4931 
 
4932 
static SEM_PC
4933 
SEM_FN_NAME (sh64_media,shlli) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4934 
{
4935 
#define FLD(f) abuf->fields.sfmt_shari.f
4936 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4937 
  int UNUSED written = 0;
4938 
  IADDR UNUSED pc = abuf->addr;
4939 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4940 
 
4941 
  {
4942 
    DI opval = SLLDI (GET_H_GR (FLD (f_left)), FLD (f_uimm6));
4943 
    SET_H_GR (FLD (f_dest), opval);
4944 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4945 
  }
4946 
 
4947 
  return vpc;
4948 
#undef FLD
4949 
}
4950 
 
4951 
/* shllil: shlli.l $rm, $uimm6, $rd */
4952 
 
4953 
static SEM_PC
4954 
SEM_FN_NAME (sh64_media,shllil) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4955 
{
4956 
#define FLD(f) abuf->fields.sfmt_shari.f
4957 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4958 
  int UNUSED written = 0;
4959 
  IADDR UNUSED pc = abuf->addr;
4960 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4961 
 
4962 
  {
4963 
    DI opval = EXTSIDI (SLLSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), ANDSI (FLD (f_uimm6), 63)));
4964 
    SET_H_GR (FLD (f_dest), opval);
4965 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4966 
  }
4967 
 
4968 
  return vpc;
4969 
#undef FLD
4970 
}
4971 
 
4972 
/* shlrd: shlrd $rm, $rn, $rd */
4973 
 
4974 
static SEM_PC
4975 
SEM_FN_NAME (sh64_media,shlrd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4976 
{
4977 
#define FLD(f) abuf->fields.sfmt_add.f
4978 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4979 
  int UNUSED written = 0;
4980 
  IADDR UNUSED pc = abuf->addr;
4981 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4982 
 
4983 
  {
4984 
    DI opval = SRLDI (GET_H_GR (FLD (f_left)), ANDDI (GET_H_GR (FLD (f_right)), 63));
4985 
    SET_H_GR (FLD (f_dest), opval);
4986 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4987 
  }
4988 
 
4989 
  return vpc;
4990 
#undef FLD
4991 
}
4992 
 
4993 
/* shlrdl: shlrd.l $rm, $rn, $rd */
4994 
 
4995 
static SEM_PC
4996 
SEM_FN_NAME (sh64_media,shlrdl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
4997 
{
4998 
#define FLD(f) abuf->fields.sfmt_add.f
4999 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5000 
  int UNUSED written = 0;
5001 
  IADDR UNUSED pc = abuf->addr;
5002 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5003 
 
5004 
  {
5005 
    DI opval = EXTSIDI (SRLSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 63)));
5006 
    SET_H_GR (FLD (f_dest), opval);
5007 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
5008 
  }
5009 
 
5010 
  return vpc;
5011 
#undef FLD
5012 
}
5013 
 
5014 
/* shlri: shlri $rm, $uimm6, $rd */
5015 
 
5016 
static SEM_PC
5017 
SEM_FN_NAME (sh64_media,shlri) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5018 
{
5019 
#define FLD(f) abuf->fields.sfmt_shari.f
5020 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5021 
  int UNUSED written = 0;
5022 
  IADDR UNUSED pc = abuf->addr;
5023 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5024 
 
5025 
  {
5026 
    DI opval = SRLDI (GET_H_GR (FLD (f_left)), FLD (f_uimm6));
5027 
    SET_H_GR (FLD (f_dest), opval);
5028 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
5029 
  }
5030 
 
5031 
  return vpc;
5032 
#undef FLD
5033 
}
5034 
 
5035 
/* shlril: shlri.l $rm, $uimm6, $rd */
5036 
 
5037 
static SEM_PC
5038 
SEM_FN_NAME (sh64_media,shlril) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5039 
{
5040 
#define FLD(f) abuf->fields.sfmt_shari.f
5041 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5042 
  int UNUSED written = 0;
5043 
  IADDR UNUSED pc = abuf->addr;
5044 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5045 
 
5046 
  {
5047 
    DI opval = EXTSIDI (SRLSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), ANDSI (FLD (f_uimm6), 63)));
5048 
    SET_H_GR (FLD (f_dest), opval);
5049 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
5050 
  }
5051 
 
5052 
  return vpc;
5053 
#undef FLD
5054 
}
5055 
 
5056 
/* shori: shori $uimm16, $rd */
5057 
 
5058 
static SEM_PC
5059 
SEM_FN_NAME (sh64_media,shori) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5060 
{
5061 
#define FLD(f) abuf->fields.sfmt_shori.f
5062 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5063 
  int UNUSED written = 0;
5064 
  IADDR UNUSED pc = abuf->addr;
5065 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5066 
 
5067 
  {
5068 
    DI opval = ORDI (SLLDI (GET_H_GR (FLD (f_dest)), 16), ZEXTSIDI (FLD (f_uimm16)));
5069 
    SET_H_GR (FLD (f_dest), opval);
5070 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
5071 
  }
5072 
 
5073 
  return vpc;
5074 
#undef FLD
5075 
}
5076 
 
5077 
/* sleep: sleep */
5078 
 
5079 
static SEM_PC
5080 
SEM_FN_NAME (sh64_media,sleep) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5081 
{
5082 
#define FLD(f) abuf->fields.sfmt_empty.f
5083 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5084 
  int UNUSED written = 0;
5085 
  IADDR UNUSED pc = abuf->addr;
5086 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5087 
 
5088 
((void) 0); /*nop*/
5089 
 
5090 
  return vpc;
5091 
#undef FLD
5092 
}
5093 
 
5094 
/* stb: st.b $rm, $disp10, $rd */
5095 
 
5096 
static SEM_PC
5097 
SEM_FN_NAME (sh64_media,stb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5098 
{
5099 
#define FLD(f) abuf->fields.sfmt_addi.f
5100 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5101 
  int UNUSED written = 0;
5102 
  IADDR UNUSED pc = abuf->addr;
5103 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5104 
 
5105 
  {
5106 
    UQI opval = ANDQI (GET_H_GR (FLD (f_dest)), 255);
5107 
    SETMEMUQI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_disp10))), opval);
5108 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5109 
  }
5110 
 
5111 
  return vpc;
5112 
#undef FLD
5113 
}
5114 
 
5115 
/* stl: st.l $rm, $disp10x4, $rd */
5116 
 
5117 
static SEM_PC
5118 
SEM_FN_NAME (sh64_media,stl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5119 
{
5120 
#define FLD(f) abuf->fields.sfmt_flds.f
5121 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5122 
  int UNUSED written = 0;
5123 
  IADDR UNUSED pc = abuf->addr;
5124 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5125 
 
5126 
  {
5127 
    SI opval = ANDSI (GET_H_GR (FLD (f_dest)), 0xffffffff);
5128 
    SETMEMSI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_disp10x4))), opval);
5129 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5130 
  }
5131 
 
5132 
  return vpc;
5133 
#undef FLD
5134 
}
5135 
 
5136 
/* stq: st.q $rm, $disp10x8, $rd */
5137 
 
5138 
static SEM_PC
5139 
SEM_FN_NAME (sh64_media,stq) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5140 
{
5141 
#define FLD(f) abuf->fields.sfmt_fldd.f
5142 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5143 
  int UNUSED written = 0;
5144 
  IADDR UNUSED pc = abuf->addr;
5145 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5146 
 
5147 
  {
5148 
    DI opval = GET_H_GR (FLD (f_dest));
5149 
    SETMEMDI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_disp10x8))), opval);
5150 
    TRACE_RESULT (current_cpu, abuf, "memory", 'D', opval);
5151 
  }
5152 
 
5153 
  return vpc;
5154 
#undef FLD
5155 
}
5156 
 
5157 
/* stw: st.w $rm, $disp10x2, $rd */
5158 
 
5159 
static SEM_PC
5160 
SEM_FN_NAME (sh64_media,stw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5161 
{
5162 
#define FLD(f) abuf->fields.sfmt_lduw.f
5163 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5164 
  int UNUSED written = 0;
5165 
  IADDR UNUSED pc = abuf->addr;
5166 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5167 
 
5168 
  {
5169 
    HI opval = ANDHI (GET_H_GR (FLD (f_dest)), 65535);
5170 
    SETMEMHI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_disp10x2))), opval);
5171 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5172 
  }
5173 
 
5174 
  return vpc;
5175 
#undef FLD
5176 
}
5177 
 
5178 
/* sthil: sthi.l $rm, $disp6, $rd */
5179 
 
5180 
static SEM_PC
5181 
SEM_FN_NAME (sh64_media,sthil) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5182 
{
5183 
#define FLD(f) abuf->fields.sfmt_getcfg.f
5184 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5185 
  int UNUSED written = 0;
5186 
  IADDR UNUSED pc = abuf->addr;
5187 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5188 
 
5189 
{
5190 
  DI tmp_addr;
5191 
  QI tmp_bytecount;
5192 
  DI tmp_val;
5193 
  tmp_addr = ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp6));
5194 
  tmp_bytecount = ADDDI (ANDDI (tmp_addr, 3), 1);
5195 
if (ANDQI (tmp_bytecount, 4)) {
5196 
  {
5197 
    SI opval = GET_H_GR (FLD (f_dest));
5198 
    SETMEMSI (current_cpu, pc, ANDDI (tmp_addr, -4), opval);
5199 
    written |= (1 << 5);
5200 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5201 
  }
5202 
} else {
5203 
if (GET_H_ENDIAN ()) {
5204 
{
5205 
  tmp_val = GET_H_GR (FLD (f_dest));
5206 
if (ANDQI (tmp_bytecount, 1)) {
5207 
{
5208 
  {
5209 
    UQI opval = ANDQI (tmp_val, 255);
5210 
    SETMEMUQI (current_cpu, pc, tmp_addr, opval);
5211 
    written |= (1 << 6);
5212 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5213 
  }
5214 
  tmp_val = SRLDI (tmp_val, 8);
5215 
}
5216 
}
5217 
if (ANDQI (tmp_bytecount, 2)) {
5218 
{
5219 
  {
5220 
    HI opval = ANDHI (tmp_val, 65535);
5221 
    SETMEMHI (current_cpu, pc, ANDDI (tmp_addr, -4), opval);
5222 
    written |= (1 << 4);
5223 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5224 
  }
5225 
  tmp_val = SRLDI (tmp_val, 16);
5226 
}
5227 
}
5228 
}
5229 
} else {
5230 
{
5231 
  tmp_val = SRLDI (GET_H_GR (FLD (f_dest)), SUBSI (32, MULSI (8, tmp_bytecount)));
5232 
if (ANDQI (tmp_bytecount, 2)) {
5233 
{
5234 
  {
5235 
    HI opval = ANDHI (tmp_val, 65535);
5236 
    SETMEMHI (current_cpu, pc, ANDDI (tmp_addr, -4), opval);
5237 
    written |= (1 << 4);
5238 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5239 
  }
5240 
  tmp_val = SRLDI (tmp_val, 16);
5241 
}
5242 
}
5243 
if (ANDQI (tmp_bytecount, 1)) {
5244 
{
5245 
  {
5246 
    UQI opval = ANDQI (tmp_val, 255);
5247 
    SETMEMUQI (current_cpu, pc, tmp_addr, opval);
5248 
    written |= (1 << 6);
5249 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5250 
  }
5251 
  tmp_val = SRLDI (tmp_val, 8);
5252 
}
5253 
}
5254 
}
5255 
}
5256 
}
5257 
}
5258 
 
5259 
  abuf->written = written;
5260 
  return vpc;
5261 
#undef FLD
5262 
}
5263 
 
5264 
/* sthiq: sthi.q $rm, $disp6, $rd */
5265 
 
5266 
static SEM_PC
5267 
SEM_FN_NAME (sh64_media,sthiq) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5268 
{
5269 
#define FLD(f) abuf->fields.sfmt_getcfg.f
5270 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5271 
  int UNUSED written = 0;
5272 
  IADDR UNUSED pc = abuf->addr;
5273 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5274 
 
5275 
{
5276 
  DI tmp_addr;
5277 
  QI tmp_bytecount;
5278 
  DI tmp_val;
5279 
  tmp_addr = ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp6));
5280 
  tmp_bytecount = ADDDI (ANDDI (tmp_addr, 7), 1);
5281 
if (ANDQI (tmp_bytecount, 8)) {
5282 
  {
5283 
    DI opval = GET_H_GR (FLD (f_dest));
5284 
    SETMEMDI (current_cpu, pc, ANDDI (tmp_addr, -8), opval);
5285 
    written |= (1 << 4);
5286 
    TRACE_RESULT (current_cpu, abuf, "memory", 'D', opval);
5287 
  }
5288 
} else {
5289 
if (GET_H_ENDIAN ()) {
5290 
{
5291 
  tmp_val = GET_H_GR (FLD (f_dest));
5292 
if (ANDQI (tmp_bytecount, 1)) {
5293 
{
5294 
  {
5295 
    UQI opval = ANDQI (tmp_val, 255);
5296 
    SETMEMUQI (current_cpu, pc, tmp_addr, opval);
5297 
    written |= (1 << 7);
5298 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5299 
  }
5300 
  tmp_val = SRLDI (tmp_val, 8);
5301 
}
5302 
}
5303 
if (ANDQI (tmp_bytecount, 2)) {
5304 
{
5305 
  {
5306 
    HI opval = ANDHI (tmp_val, 65535);
5307 
    SETMEMHI (current_cpu, pc, ANDDI (tmp_addr, -4), opval);
5308 
    written |= (1 << 5);
5309 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5310 
  }
5311 
  tmp_val = SRLDI (tmp_val, 16);
5312 
}
5313 
}
5314 
if (ANDQI (tmp_bytecount, 4)) {
5315 
{
5316 
  {
5317 
    SI opval = ANDSI (tmp_val, 0xffffffff);
5318 
    SETMEMSI (current_cpu, pc, ANDDI (tmp_addr, -8), opval);
5319 
    written |= (1 << 6);
5320 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5321 
  }
5322 
  tmp_val = SRLDI (tmp_val, 32);
5323 
}
5324 
}
5325 
}
5326 
} else {
5327 
{
5328 
  tmp_val = SRLDI (GET_H_GR (FLD (f_dest)), SUBSI (64, MULSI (8, tmp_bytecount)));
5329 
if (ANDQI (tmp_bytecount, 4)) {
5330 
{
5331 
  {
5332 
    SI opval = ANDSI (tmp_val, 0xffffffff);
5333 
    SETMEMSI (current_cpu, pc, ANDDI (tmp_addr, -8), opval);
5334 
    written |= (1 << 6);
5335 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5336 
  }
5337 
  tmp_val = SRLDI (tmp_val, 32);
5338 
}
5339 
}
5340 
if (ANDQI (tmp_bytecount, 2)) {
5341 
{
5342 
  {
5343 
    HI opval = ANDHI (tmp_val, 65535);
5344 
    SETMEMHI (current_cpu, pc, ANDDI (tmp_addr, -4), opval);
5345 
    written |= (1 << 5);
5346 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5347 
  }
5348 
  tmp_val = SRLDI (tmp_val, 16);
5349 
}
5350 
}
5351 
if (ANDQI (tmp_bytecount, 1)) {
5352 
{
5353 
  {
5354 
    UQI opval = ANDQI (tmp_val, 255);
5355 
    SETMEMUQI (current_cpu, pc, tmp_addr, opval);
5356 
    written |= (1 << 7);
5357 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5358 
  }
5359 
  tmp_val = SRLDI (tmp_val, 8);
5360 
}
5361 
}
5362 
}
5363 
}
5364 
}
5365 
}
5366 
 
5367 
  abuf->written = written;
5368 
  return vpc;
5369 
#undef FLD
5370 
}
5371 
 
5372 
/* stlol: stlo.l $rm, $disp6, $rd */
5373 
 
5374 
static SEM_PC
5375 
SEM_FN_NAME (sh64_media,stlol) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5376 
{
5377 
#define FLD(f) abuf->fields.sfmt_getcfg.f
5378 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5379 
  int UNUSED written = 0;
5380 
  IADDR UNUSED pc = abuf->addr;
5381 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5382 
 
5383 
{
5384 
  DI tmp_addr;
5385 
  QI tmp_bytecount;
5386 
  DI tmp_val;
5387 
  tmp_addr = ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp6));
5388 
  tmp_bytecount = SUBSI (4, ANDDI (tmp_addr, 3));
5389 
if (ANDQI (tmp_bytecount, 4)) {
5390 
  {
5391 
    USI opval = GET_H_GR (FLD (f_dest));
5392 
    SETMEMUSI (current_cpu, pc, tmp_addr, opval);
5393 
    written |= (1 << 6);
5394 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5395 
  }
5396 
} else {
5397 
if (GET_H_ENDIAN ()) {
5398 
{
5399 
  tmp_val = SRLDI (GET_H_GR (FLD (f_dest)), SUBSI (32, MULSI (8, tmp_bytecount)));
5400 
if (ANDQI (tmp_bytecount, 2)) {
5401 
{
5402 
  {
5403 
    UHI opval = ANDHI (tmp_val, 65535);
5404 
    SETMEMUHI (current_cpu, pc, ANDDI (ADDDI (tmp_addr, 1), -2), opval);
5405 
    written |= (1 << 4);
5406 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5407 
  }
5408 
  tmp_val = SRLDI (tmp_val, 16);
5409 
}
5410 
}
5411 
if (ANDQI (tmp_bytecount, 1)) {
5412 
{
5413 
  {
5414 
    UQI opval = ANDQI (tmp_val, 255);
5415 
    SETMEMUQI (current_cpu, pc, tmp_addr, opval);
5416 
    written |= (1 << 5);
5417 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5418 
  }
5419 
  tmp_val = SRLDI (tmp_val, 8);
5420 
}
5421 
}
5422 
}
5423 
} else {
5424 
{
5425 
  tmp_val = GET_H_GR (FLD (f_dest));
5426 
if (ANDQI (tmp_bytecount, 1)) {
5427 
{
5428 
  {
5429 
    UQI opval = ANDQI (tmp_val, 255);
5430 
    SETMEMUQI (current_cpu, pc, tmp_addr, opval);
5431 
    written |= (1 << 5);
5432 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5433 
  }
5434 
  tmp_val = SRLDI (tmp_val, 8);
5435 
}
5436 
}
5437 
if (ANDQI (tmp_bytecount, 2)) {
5438 
{
5439 
  {
5440 
    UHI opval = ANDHI (tmp_val, 65535);
5441 
    SETMEMUHI (current_cpu, pc, ANDDI (ADDDI (tmp_addr, 1), -2), opval);
5442 
    written |= (1 << 4);
5443 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5444 
  }
5445 
  tmp_val = SRLDI (tmp_val, 16);
5446 
}
5447 
}
5448 
}
5449 
}
5450 
}
5451 
}
5452 
 
5453 
  abuf->written = written;
5454 
  return vpc;
5455 
#undef FLD
5456 
}
5457 
 
5458 
/* stloq: stlo.q $rm, $disp6, $rd */
5459 
 
5460 
static SEM_PC
5461 
SEM_FN_NAME (sh64_media,stloq) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5462 
{
5463 
#define FLD(f) abuf->fields.sfmt_getcfg.f
5464 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5465 
  int UNUSED written = 0;
5466 
  IADDR UNUSED pc = abuf->addr;
5467 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5468 
 
5469 
{
5470 
  DI tmp_addr;
5471 
  QI tmp_bytecount;
5472 
  DI tmp_val;
5473 
  tmp_addr = ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp6));
5474 
  tmp_bytecount = SUBSI (8, ANDDI (tmp_addr, 7));
5475 
if (ANDQI (tmp_bytecount, 8)) {
5476 
  {
5477 
    UDI opval = GET_H_GR (FLD (f_dest));
5478 
    SETMEMUDI (current_cpu, pc, tmp_addr, opval);
5479 
    written |= (1 << 4);
5480 
    TRACE_RESULT (current_cpu, abuf, "memory", 'D', opval);
5481 
  }
5482 
} else {
5483 
if (GET_H_ENDIAN ()) {
5484 
{
5485 
  tmp_val = SRLDI (GET_H_GR (FLD (f_dest)), SUBSI (64, MULSI (8, tmp_bytecount)));
5486 
if (ANDQI (tmp_bytecount, 4)) {
5487 
{
5488 
  {
5489 
    USI opval = ANDSI (tmp_val, 0xffffffff);
5490 
    SETMEMUSI (current_cpu, pc, ANDDI (ADDDI (tmp_addr, 3), -4), opval);
5491 
    written |= (1 << 7);
5492 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5493 
  }
5494 
  tmp_val = SRLDI (tmp_val, 32);
5495 
}
5496 
}
5497 
if (ANDQI (tmp_bytecount, 2)) {
5498 
{
5499 
  {
5500 
    UHI opval = ANDHI (tmp_val, 65535);
5501 
    SETMEMUHI (current_cpu, pc, ANDDI (ADDDI (tmp_addr, 1), -2), opval);
5502 
    written |= (1 << 5);
5503 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5504 
  }
5505 
  tmp_val = SRLDI (tmp_val, 16);
5506 
}
5507 
}
5508 
if (ANDQI (tmp_bytecount, 1)) {
5509 
{
5510 
  {
5511 
    UQI opval = ANDQI (tmp_val, 255);
5512 
    SETMEMUQI (current_cpu, pc, tmp_addr, opval);
5513 
    written |= (1 << 6);
5514 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5515 
  }
5516 
  tmp_val = SRLDI (tmp_val, 8);
5517 
}
5518 
}
5519 
}
5520 
} else {
5521 
{
5522 
  tmp_val = GET_H_GR (FLD (f_dest));
5523 
if (ANDQI (tmp_bytecount, 1)) {
5524 
{
5525 
  {
5526 
    UQI opval = ANDQI (tmp_val, 255);
5527 
    SETMEMUQI (current_cpu, pc, tmp_addr, opval);
5528 
    written |= (1 << 6);
5529 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5530 
  }
5531 
  tmp_val = SRLDI (tmp_val, 8);
5532 
}
5533 
}
5534 
if (ANDQI (tmp_bytecount, 2)) {
5535 
{
5536 
  {
5537 
    UHI opval = ANDHI (tmp_val, 65535);
5538 
    SETMEMUHI (current_cpu, pc, ANDDI (ADDDI (tmp_addr, 1), -2), opval);
5539 
    written |= (1 << 5);
5540 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5541 
  }
5542 
  tmp_val = SRLDI (tmp_val, 16);
5543 
}
5544 
}
5545 
if (ANDQI (tmp_bytecount, 4)) {
5546 
{
5547 
  {
5548 
    USI opval = ANDSI (tmp_val, 0xffffffff);
5549 
    SETMEMUSI (current_cpu, pc, ANDDI (ADDDI (tmp_addr, 3), -4), opval);
5550 
    written |= (1 << 7);
5551 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5552 
  }
5553 
  tmp_val = SRLDI (tmp_val, 32);
5554 
}
5555 
}
5556 
}
5557 
}
5558 
}
5559 
}
5560 
 
5561 
  abuf->written = written;
5562 
  return vpc;
5563 
#undef FLD
5564 
}
5565 
 
5566 
/* stxb: stx.b $rm, $rn, $rd */
5567 
 
5568 
static SEM_PC
5569 
SEM_FN_NAME (sh64_media,stxb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5570 
{
5571 
#define FLD(f) abuf->fields.sfmt_add.f
5572 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5573 
  int UNUSED written = 0;
5574 
  IADDR UNUSED pc = abuf->addr;
5575 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5576 
 
5577 
  {
5578 
    UQI opval = SUBWORDDIQI (GET_H_GR (FLD (f_dest)), 7);
5579 
    SETMEMUQI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right))), opval);
5580 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5581 
  }
5582 
 
5583 
  return vpc;
5584 
#undef FLD
5585 
}
5586 
 
5587 
/* stxl: stx.l $rm, $rn, $rd */
5588 
 
5589 
static SEM_PC
5590 
SEM_FN_NAME (sh64_media,stxl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5591 
{
5592 
#define FLD(f) abuf->fields.sfmt_add.f
5593 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5594 
  int UNUSED written = 0;
5595 
  IADDR UNUSED pc = abuf->addr;
5596 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5597 
 
5598 
  {
5599 
    SI opval = SUBWORDDISI (GET_H_GR (FLD (f_dest)), 1);
5600 
    SETMEMSI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right))), opval);
5601 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5602 
  }
5603 
 
5604 
  return vpc;
5605 
#undef FLD
5606 
}
5607 
 
5608 
/* stxq: stx.q $rm, $rn, $rd */
5609 
 
5610 
static SEM_PC
5611 
SEM_FN_NAME (sh64_media,stxq) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5612 
{
5613 
#define FLD(f) abuf->fields.sfmt_add.f
5614 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5615 
  int UNUSED written = 0;
5616 
  IADDR UNUSED pc = abuf->addr;
5617 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5618 
 
5619 
  {
5620 
    DI opval = GET_H_GR (FLD (f_dest));
5621 
    SETMEMDI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right))), opval);
5622 
    TRACE_RESULT (current_cpu, abuf, "memory", 'D', opval);
5623 
  }
5624 
 
5625 
  return vpc;
5626 
#undef FLD
5627 
}
5628 
 
5629 
/* stxw: stx.w $rm, $rn, $rd */
5630 
 
5631 
static SEM_PC
5632 
SEM_FN_NAME (sh64_media,stxw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5633 
{
5634 
#define FLD(f) abuf->fields.sfmt_add.f
5635 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5636 
  int UNUSED written = 0;
5637 
  IADDR UNUSED pc = abuf->addr;
5638 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5639 
 
5640 
  {
5641 
    HI opval = SUBWORDDIHI (GET_H_GR (FLD (f_dest)), 3);
5642 
    SETMEMHI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right))), opval);
5643 
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5644 
  }
5645 
 
5646 
  return vpc;
5647 
#undef FLD
5648 
}
5649 
 
5650 
/* sub: sub $rm, $rn, $rd */
5651 
 
5652 
static SEM_PC
5653 
SEM_FN_NAME (sh64_media,sub) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5654 
{
5655 
#define FLD(f) abuf->fields.sfmt_add.f
5656 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5657 
  int UNUSED written = 0;
5658 
  IADDR UNUSED pc = abuf->addr;
5659 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5660 
 
5661 
  {
5662 
    DI opval = SUBDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)));
5663 
    SET_H_GR (FLD (f_dest), opval);
5664 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
5665 
  }
5666 
 
5667 
  return vpc;
5668 
#undef FLD
5669 
}
5670 
 
5671 
/* subl: sub.l $rm, $rn, $rd */
5672 
 
5673 
static SEM_PC
5674 
SEM_FN_NAME (sh64_media,subl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5675 
{
5676 
#define FLD(f) abuf->fields.sfmt_add.f
5677 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5678 
  int UNUSED written = 0;
5679 
  IADDR UNUSED pc = abuf->addr;
5680 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5681 
 
5682 
  {
5683 
    DI opval = EXTSIDI (SUBSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), SUBWORDDISI (GET_H_GR (FLD (f_right)), 1)));
5684 
    SET_H_GR (FLD (f_dest), opval);
5685 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
5686 
  }
5687 
 
5688 
  return vpc;
5689 
#undef FLD
5690 
}
5691 
 
5692 
/* swapq: swap.q $rm, $rn, $rd */
5693 
 
5694 
static SEM_PC
5695 
SEM_FN_NAME (sh64_media,swapq) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5696 
{
5697 
#define FLD(f) abuf->fields.sfmt_add.f
5698 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5699 
  int UNUSED written = 0;
5700 
  IADDR UNUSED pc = abuf->addr;
5701 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5702 
 
5703 
{
5704 
  DI tmp_addr;
5705 
  DI tmp_temp;
5706 
  tmp_addr = ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)));
5707 
  tmp_temp = GETMEMDI (current_cpu, pc, tmp_addr);
5708 
  {
5709 
    DI opval = GET_H_GR (FLD (f_dest));
5710 
    SETMEMDI (current_cpu, pc, tmp_addr, opval);
5711 
    TRACE_RESULT (current_cpu, abuf, "memory", 'D', opval);
5712 
  }
5713 
  {
5714 
    DI opval = tmp_temp;
5715 
    SET_H_GR (FLD (f_dest), opval);
5716 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
5717 
  }
5718 
}
5719 
 
5720 
  return vpc;
5721 
#undef FLD
5722 
}
5723 
 
5724 
/* synci: synci */
5725 
 
5726 
static SEM_PC
5727 
SEM_FN_NAME (sh64_media,synci) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5728 
{
5729 
#define FLD(f) abuf->fields.sfmt_empty.f
5730 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5731 
  int UNUSED written = 0;
5732 
  IADDR UNUSED pc = abuf->addr;
5733 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5734 
 
5735 
((void) 0); /*nop*/
5736 
 
5737 
  return vpc;
5738 
#undef FLD
5739 
}
5740 
 
5741 
/* synco: synco */
5742 
 
5743 
static SEM_PC
5744 
SEM_FN_NAME (sh64_media,synco) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5745 
{
5746 
#define FLD(f) abuf->fields.sfmt_empty.f
5747 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5748 
  int UNUSED written = 0;
5749 
  IADDR UNUSED pc = abuf->addr;
5750 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5751 
 
5752 
((void) 0); /*nop*/
5753 
 
5754 
  return vpc;
5755 
#undef FLD
5756 
}
5757 
 
5758 
/* trapa: trapa $rm */
5759 
 
5760 
static SEM_PC
5761 
SEM_FN_NAME (sh64_media,trapa) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5762 
{
5763 
#define FLD(f) abuf->fields.sfmt_xori.f
5764 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5765 
  int UNUSED written = 0;
5766 
  IADDR UNUSED pc = abuf->addr;
5767 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5768 
 
5769 
sh64_trapa (current_cpu, GET_H_GR (FLD (f_left)), pc);
5770 
 
5771 
  return vpc;
5772 
#undef FLD
5773 
}
5774 
 
5775 
/* xor: xor $rm, $rn, $rd */
5776 
 
5777 
static SEM_PC
5778 
SEM_FN_NAME (sh64_media,xor) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5779 
{
5780 
#define FLD(f) abuf->fields.sfmt_add.f
5781 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5782 
  int UNUSED written = 0;
5783 
  IADDR UNUSED pc = abuf->addr;
5784 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5785 
 
5786 
  {
5787 
    DI opval = XORDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)));
5788 
    SET_H_GR (FLD (f_dest), opval);
5789 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
5790 
  }
5791 
 
5792 
  return vpc;
5793 
#undef FLD
5794 
}
5795 
 
5796 
/* xori: xori $rm, $imm6, $rd */
5797 
 
5798 
static SEM_PC
5799 
SEM_FN_NAME (sh64_media,xori) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
5800 
{
5801 
#define FLD(f) abuf->fields.sfmt_xori.f
5802 
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5803 
  int UNUSED written = 0;
5804 
  IADDR UNUSED pc = abuf->addr;
5805 
  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5806 
 
5807 
  {
5808 
    DI opval = XORDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_imm6)));
5809 
    SET_H_GR (FLD (f_dest), opval);
5810 
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
5811 
  }
5812 
 
5813 
  return vpc;
5814 
#undef FLD
5815 
}
5816 
 
5817 
/* Table of all semantic fns.  */
5818 
 
5819 
static const struct sem_fn_desc sem_fns[] = {
5820 
  { SH64_MEDIA_INSN_X_INVALID, SEM_FN_NAME (sh64_media,x_invalid) },
5821 
  { SH64_MEDIA_INSN_X_AFTER, SEM_FN_NAME (sh64_media,x_after) },
5822 
  { SH64_MEDIA_INSN_X_BEFORE, SEM_FN_NAME (sh64_media,x_before) },
5823 
  { SH64_MEDIA_INSN_X_CTI_CHAIN, SEM_FN_NAME (sh64_media,x_cti_chain) },
5824 
  { SH64_MEDIA_INSN_X_CHAIN, SEM_FN_NAME (sh64_media,x_chain) },
5825 
  { SH64_MEDIA_INSN_X_BEGIN, SEM_FN_NAME (sh64_media,x_begin) },
5826 
  { SH64_MEDIA_INSN_ADD, SEM_FN_NAME (sh64_media,add) },
5827 
  { SH64_MEDIA_INSN_ADDL, SEM_FN_NAME (sh64_media,addl) },
5828 
  { SH64_MEDIA_INSN_ADDI, SEM_FN_NAME (sh64_media,addi) },
5829 
  { SH64_MEDIA_INSN_ADDIL, SEM_FN_NAME (sh64_media,addil) },
5830 
  { SH64_MEDIA_INSN_ADDZL, SEM_FN_NAME (sh64_media,addzl) },
5831 
  { SH64_MEDIA_INSN_ALLOCO, SEM_FN_NAME (sh64_media,alloco) },
5832 
  { SH64_MEDIA_INSN_AND, SEM_FN_NAME (sh64_media,and) },
5833 
  { SH64_MEDIA_INSN_ANDC, SEM_FN_NAME (sh64_media,andc) },
5834 
  { SH64_MEDIA_INSN_ANDI, SEM_FN_NAME (sh64_media,andi) },
5835 
  { SH64_MEDIA_INSN_BEQ, SEM_FN_NAME (sh64_media,beq) },
5836 
  { SH64_MEDIA_INSN_BEQI, SEM_FN_NAME (sh64_media,beqi) },
5837 
  { SH64_MEDIA_INSN_BGE, SEM_FN_NAME (sh64_media,bge) },
5838 
  { SH64_MEDIA_INSN_BGEU, SEM_FN_NAME (sh64_media,bgeu) },
5839 
  { SH64_MEDIA_INSN_BGT, SEM_FN_NAME (sh64_media,bgt) },
5840 
  { SH64_MEDIA_INSN_BGTU, SEM_FN_NAME (sh64_media,bgtu) },
5841 
  { SH64_MEDIA_INSN_BLINK, SEM_FN_NAME (sh64_media,blink) },
5842 
  { SH64_MEDIA_INSN_BNE, SEM_FN_NAME (sh64_media,bne) },
5843 
  { SH64_MEDIA_INSN_BNEI, SEM_FN_NAME (sh64_media,bnei) },
5844 
  { SH64_MEDIA_INSN_BRK, SEM_FN_NAME (sh64_media,brk) },
5845 
  { SH64_MEDIA_INSN_BYTEREV, SEM_FN_NAME (sh64_media,byterev) },
5846 
  { SH64_MEDIA_INSN_CMPEQ, SEM_FN_NAME (sh64_media,cmpeq) },
5847 
  { SH64_MEDIA_INSN_CMPGT, SEM_FN_NAME (sh64_media,cmpgt) },
5848 
  { SH64_MEDIA_INSN_CMPGTU, SEM_FN_NAME (sh64_media,cmpgtu) },
5849 
  { SH64_MEDIA_INSN_CMVEQ, SEM_FN_NAME (sh64_media,cmveq) },
5850 
  { SH64_MEDIA_INSN_CMVNE, SEM_FN_NAME (sh64_media,cmvne) },
5851 
  { SH64_MEDIA_INSN_FABSD, SEM_FN_NAME (sh64_media,fabsd) },
5852 
  { SH64_MEDIA_INSN_FABSS, SEM_FN_NAME (sh64_media,fabss) },
5853 
  { SH64_MEDIA_INSN_FADDD, SEM_FN_NAME (sh64_media,faddd) },
5854 
  { SH64_MEDIA_INSN_FADDS, SEM_FN_NAME (sh64_media,fadds) },
5855 
  { SH64_MEDIA_INSN_FCMPEQD, SEM_FN_NAME (sh64_media,fcmpeqd) },
5856 
  { SH64_MEDIA_INSN_FCMPEQS, SEM_FN_NAME (sh64_media,fcmpeqs) },
5857 
  { SH64_MEDIA_INSN_FCMPGED, SEM_FN_NAME (sh64_media,fcmpged) },
5858 
  { SH64_MEDIA_INSN_FCMPGES, SEM_FN_NAME (sh64_media,fcmpges) },
5859 
  { SH64_MEDIA_INSN_FCMPGTD, SEM_FN_NAME (sh64_media,fcmpgtd) },
5860 
  { SH64_MEDIA_INSN_FCMPGTS, SEM_FN_NAME (sh64_media,fcmpgts) },
5861 
  { SH64_MEDIA_INSN_FCMPUND, SEM_FN_NAME (sh64_media,fcmpund) },
5862 
  { SH64_MEDIA_INSN_FCMPUNS, SEM_FN_NAME (sh64_media,fcmpuns) },
5863 
  { SH64_MEDIA_INSN_FCNVDS, SEM_FN_NAME (sh64_media,fcnvds) },
5864 
  { SH64_MEDIA_INSN_FCNVSD, SEM_FN_NAME (sh64_media,fcnvsd) },
5865 
  { SH64_MEDIA_INSN_FDIVD, SEM_FN_NAME (sh64_media,fdivd) },
5866 
  { SH64_MEDIA_INSN_FDIVS, SEM_FN_NAME (sh64_media,fdivs) },
5867 
  { SH64_MEDIA_INSN_FGETSCR, SEM_FN_NAME (sh64_media,fgetscr) },
5868 
  { SH64_MEDIA_INSN_FIPRS, SEM_FN_NAME (sh64_media,fiprs) },
5869 
  { SH64_MEDIA_INSN_FLDD, SEM_FN_NAME (sh64_media,fldd) },
5870 
  { SH64_MEDIA_INSN_FLDP, SEM_FN_NAME (sh64_media,fldp) },
5871 
  { SH64_MEDIA_INSN_FLDS, SEM_FN_NAME (sh64_media,flds) },
5872 
  { SH64_MEDIA_INSN_FLDXD, SEM_FN_NAME (sh64_media,fldxd) },
5873 
  { SH64_MEDIA_INSN_FLDXP, SEM_FN_NAME (sh64_media,fldxp) },
5874 
  { SH64_MEDIA_INSN_FLDXS, SEM_FN_NAME (sh64_media,fldxs) },
5875 
  { SH64_MEDIA_INSN_FLOATLD, SEM_FN_NAME (sh64_media,floatld) },
5876 
  { SH64_MEDIA_INSN_FLOATLS, SEM_FN_NAME (sh64_media,floatls) },
5877 
  { SH64_MEDIA_INSN_FLOATQD, SEM_FN_NAME (sh64_media,floatqd) },
5878 
  { SH64_MEDIA_INSN_FLOATQS, SEM_FN_NAME (sh64_media,floatqs) },
5879 
  { SH64_MEDIA_INSN_FMACS, SEM_FN_NAME (sh64_media,fmacs) },
5880 
  { SH64_MEDIA_INSN_FMOVD, SEM_FN_NAME (sh64_media,fmovd) },
5881 
  { SH64_MEDIA_INSN_FMOVDQ, SEM_FN_NAME (sh64_media,fmovdq) },
5882 
  { SH64_MEDIA_INSN_FMOVLS, SEM_FN_NAME (sh64_media,fmovls) },
5883 
  { SH64_MEDIA_INSN_FMOVQD, SEM_FN_NAME (sh64_media,fmovqd) },
5884 
  { SH64_MEDIA_INSN_FMOVS, SEM_FN_NAME (sh64_media,fmovs) },
5885 
  { SH64_MEDIA_INSN_FMOVSL, SEM_FN_NAME (sh64_media,fmovsl) },
5886 
  { SH64_MEDIA_INSN_FMULD, SEM_FN_NAME (sh64_media,fmuld) },
5887 
  { SH64_MEDIA_INSN_FMULS, SEM_FN_NAME (sh64_media,fmuls) },
5888 
  { SH64_MEDIA_INSN_FNEGD, SEM_FN_NAME (sh64_media,fnegd) },
5889 
  { SH64_MEDIA_INSN_FNEGS, SEM_FN_NAME (sh64_media,fnegs) },
5890 
  { SH64_MEDIA_INSN_FPUTSCR, SEM_FN_NAME (sh64_media,fputscr) },
5891 
  { SH64_MEDIA_INSN_FSQRTD, SEM_FN_NAME (sh64_media,fsqrtd) },
5892 
  { SH64_MEDIA_INSN_FSQRTS, SEM_FN_NAME (sh64_media,fsqrts) },
5893 
  { SH64_MEDIA_INSN_FSTD, SEM_FN_NAME (sh64_media,fstd) },
5894 
  { SH64_MEDIA_INSN_FSTP, SEM_FN_NAME (sh64_media,fstp) },
5895 
  { SH64_MEDIA_INSN_FSTS, SEM_FN_NAME (sh64_media,fsts) },
5896 
  { SH64_MEDIA_INSN_FSTXD, SEM_FN_NAME (sh64_media,fstxd) },
5897 
  { SH64_MEDIA_INSN_FSTXP, SEM_FN_NAME (sh64_media,fstxp) },
5898 
  { SH64_MEDIA_INSN_FSTXS, SEM_FN_NAME (sh64_media,fstxs) },
5899 
  { SH64_MEDIA_INSN_FSUBD, SEM_FN_NAME (sh64_media,fsubd) },
5900 
  { SH64_MEDIA_INSN_FSUBS, SEM_FN_NAME (sh64_media,fsubs) },
5901 
  { SH64_MEDIA_INSN_FTRCDL, SEM_FN_NAME (sh64_media,ftrcdl) },
5902 
  { SH64_MEDIA_INSN_FTRCSL, SEM_FN_NAME (sh64_media,ftrcsl) },
5903 
  { SH64_MEDIA_INSN_FTRCDQ, SEM_FN_NAME (sh64_media,ftrcdq) },
5904 
  { SH64_MEDIA_INSN_FTRCSQ, SEM_FN_NAME (sh64_media,ftrcsq) },
5905 
  { SH64_MEDIA_INSN_FTRVS, SEM_FN_NAME (sh64_media,ftrvs) },
5906 
  { SH64_MEDIA_INSN_GETCFG, SEM_FN_NAME (sh64_media,getcfg) },
5907 
  { SH64_MEDIA_INSN_GETCON, SEM_FN_NAME (sh64_media,getcon) },
5908 
  { SH64_MEDIA_INSN_GETTR, SEM_FN_NAME (sh64_media,gettr) },
5909 
  { SH64_MEDIA_INSN_ICBI, SEM_FN_NAME (sh64_media,icbi) },
5910 
  { SH64_MEDIA_INSN_LDB, SEM_FN_NAME (sh64_media,ldb) },
5911 
  { SH64_MEDIA_INSN_LDL, SEM_FN_NAME (sh64_media,ldl) },
5912 
  { SH64_MEDIA_INSN_LDQ, SEM_FN_NAME (sh64_media,ldq) },
5913 
  { SH64_MEDIA_INSN_LDUB, SEM_FN_NAME (sh64_media,ldub) },
5914 
  { SH64_MEDIA_INSN_LDUW, SEM_FN_NAME (sh64_media,lduw) },
5915 
  { SH64_MEDIA_INSN_LDW, SEM_FN_NAME (sh64_media,ldw) },
5916 
  { SH64_MEDIA_INSN_LDHIL, SEM_FN_NAME (sh64_media,ldhil) },
5917 
  { SH64_MEDIA_INSN_LDHIQ, SEM_FN_NAME (sh64_media,ldhiq) },
5918 
  { SH64_MEDIA_INSN_LDLOL, SEM_FN_NAME (sh64_media,ldlol) },
5919 
  { SH64_MEDIA_INSN_LDLOQ, SEM_FN_NAME (sh64_media,ldloq) },
5920 
  { SH64_MEDIA_INSN_LDXB, SEM_FN_NAME (sh64_media,ldxb) },
5921 
  { SH64_MEDIA_INSN_LDXL, SEM_FN_NAME (sh64_media,ldxl) },
5922 
  { SH64_MEDIA_INSN_LDXQ, SEM_FN_NAME (sh64_media,ldxq) },
5923 
  { SH64_MEDIA_INSN_LDXUB, SEM_FN_NAME (sh64_media,ldxub) },
5924 
  { SH64_MEDIA_INSN_LDXUW, SEM_FN_NAME (sh64_media,ldxuw) },
5925 
  { SH64_MEDIA_INSN_LDXW, SEM_FN_NAME (sh64_media,ldxw) },
5926 
  { SH64_MEDIA_INSN_MABSL, SEM_FN_NAME (sh64_media,mabsl) },
5927 
  { SH64_MEDIA_INSN_MABSW, SEM_FN_NAME (sh64_media,mabsw) },
5928 
  { SH64_MEDIA_INSN_MADDL, SEM_FN_NAME (sh64_media,maddl) },
5929 
  { SH64_MEDIA_INSN_MADDW, SEM_FN_NAME (sh64_media,maddw) },
5930 
  { SH64_MEDIA_INSN_MADDSL, SEM_FN_NAME (sh64_media,maddsl) },
5931 
  { SH64_MEDIA_INSN_MADDSUB, SEM_FN_NAME (sh64_media,maddsub) },
5932 
  { SH64_MEDIA_INSN_MADDSW, SEM_FN_NAME (sh64_media,maddsw) },
5933 
  { SH64_MEDIA_INSN_MCMPEQB, SEM_FN_NAME (sh64_media,mcmpeqb) },
5934 
  { SH64_MEDIA_INSN_MCMPEQL, SEM_FN_NAME (sh64_media,mcmpeql) },
5935 
  { SH64_MEDIA_INSN_MCMPEQW, SEM_FN_NAME (sh64_media,mcmpeqw) },
5936 
  { SH64_MEDIA_INSN_MCMPGTL, SEM_FN_NAME (sh64_media,mcmpgtl) },
5937 
  { SH64_MEDIA_INSN_MCMPGTUB, SEM_FN_NAME (sh64_media,mcmpgtub) },
5938 
  { SH64_MEDIA_INSN_MCMPGTW, SEM_FN_NAME (sh64_media,mcmpgtw) },
5939 
  { SH64_MEDIA_INSN_MCMV, SEM_FN_NAME (sh64_media,mcmv) },
5940 
  { SH64_MEDIA_INSN_MCNVSLW, SEM_FN_NAME (sh64_media,mcnvslw) },
5941 
  { SH64_MEDIA_INSN_MCNVSWB, SEM_FN_NAME (sh64_media,mcnvswb) },
5942 
  { SH64_MEDIA_INSN_MCNVSWUB, SEM_FN_NAME (sh64_media,mcnvswub) },
5943 
  { SH64_MEDIA_INSN_MEXTR1, SEM_FN_NAME (sh64_media,mextr1) },
5944 
  { SH64_MEDIA_INSN_MEXTR2, SEM_FN_NAME (sh64_media,mextr2) },
5945 
  { SH64_MEDIA_INSN_MEXTR3, SEM_FN_NAME (sh64_media,mextr3) },
5946 
  { SH64_MEDIA_INSN_MEXTR4, SEM_FN_NAME (sh64_media,mextr4) },
5947 
  { SH64_MEDIA_INSN_MEXTR5, SEM_FN_NAME (sh64_media,mextr5) },
5948 
  { SH64_MEDIA_INSN_MEXTR6, SEM_FN_NAME (sh64_media,mextr6) },
5949 
  { SH64_MEDIA_INSN_MEXTR7, SEM_FN_NAME (sh64_media,mextr7) },
5950 
  { SH64_MEDIA_INSN_MMACFXWL, SEM_FN_NAME (sh64_media,mmacfxwl) },
5951 
  { SH64_MEDIA_INSN_MMACNFX_WL, SEM_FN_NAME (sh64_media,mmacnfx_wl) },
5952 
  { SH64_MEDIA_INSN_MMULL, SEM_FN_NAME (sh64_media,mmull) },
5953 
  { SH64_MEDIA_INSN_MMULW, SEM_FN_NAME (sh64_media,mmulw) },
5954 
  { SH64_MEDIA_INSN_MMULFXL, SEM_FN_NAME (sh64_media,mmulfxl) },
5955 
  { SH64_MEDIA_INSN_MMULFXW, SEM_FN_NAME (sh64_media,mmulfxw) },
5956 
  { SH64_MEDIA_INSN_MMULFXRPW, SEM_FN_NAME (sh64_media,mmulfxrpw) },
5957 
  { SH64_MEDIA_INSN_MMULHIWL, SEM_FN_NAME (sh64_media,mmulhiwl) },
5958 
  { SH64_MEDIA_INSN_MMULLOWL, SEM_FN_NAME (sh64_media,mmullowl) },
5959 
  { SH64_MEDIA_INSN_MMULSUMWQ, SEM_FN_NAME (sh64_media,mmulsumwq) },
5960 
  { SH64_MEDIA_INSN_MOVI, SEM_FN_NAME (sh64_media,movi) },
5961 
  { SH64_MEDIA_INSN_MPERMW, SEM_FN_NAME (sh64_media,mpermw) },
5962 
  { SH64_MEDIA_INSN_MSADUBQ, SEM_FN_NAME (sh64_media,msadubq) },
5963 
  { SH64_MEDIA_INSN_MSHALDSL, SEM_FN_NAME (sh64_media,mshaldsl) },
5964 
  { SH64_MEDIA_INSN_MSHALDSW, SEM_FN_NAME (sh64_media,mshaldsw) },
5965 
  { SH64_MEDIA_INSN_MSHARDL, SEM_FN_NAME (sh64_media,mshardl) },
5966 
  { SH64_MEDIA_INSN_MSHARDW, SEM_FN_NAME (sh64_media,mshardw) },
5967 
  { SH64_MEDIA_INSN_MSHARDSQ, SEM_FN_NAME (sh64_media,mshardsq) },
5968 
  { SH64_MEDIA_INSN_MSHFHIB, SEM_FN_NAME (sh64_media,mshfhib) },
5969 
  { SH64_MEDIA_INSN_MSHFHIL, SEM_FN_NAME (sh64_media,mshfhil) },
5970 
  { SH64_MEDIA_INSN_MSHFHIW, SEM_FN_NAME (sh64_media,mshfhiw) },
5971 
  { SH64_MEDIA_INSN_MSHFLOB, SEM_FN_NAME (sh64_media,mshflob) },
5972 
  { SH64_MEDIA_INSN_MSHFLOL, SEM_FN_NAME (sh64_media,mshflol) },
5973 
  { SH64_MEDIA_INSN_MSHFLOW, SEM_FN_NAME (sh64_media,mshflow) },
5974 
  { SH64_MEDIA_INSN_MSHLLDL, SEM_FN_NAME (sh64_media,mshlldl) },
5975 
  { SH64_MEDIA_INSN_MSHLLDW, SEM_FN_NAME (sh64_media,mshlldw) },
5976 
  { SH64_MEDIA_INSN_MSHLRDL, SEM_FN_NAME (sh64_media,mshlrdl) },
5977 
  { SH64_MEDIA_INSN_MSHLRDW, SEM_FN_NAME (sh64_media,mshlrdw) },
5978 
  { SH64_MEDIA_INSN_MSUBL, SEM_FN_NAME (sh64_media,msubl) },
5979 
  { SH64_MEDIA_INSN_MSUBW, SEM_FN_NAME (sh64_media,msubw) },
5980 
  { SH64_MEDIA_INSN_MSUBSL, SEM_FN_NAME (sh64_media,msubsl) },
5981 
  { SH64_MEDIA_INSN_MSUBSUB, SEM_FN_NAME (sh64_media,msubsub) },
5982 
  { SH64_MEDIA_INSN_MSUBSW, SEM_FN_NAME (sh64_media,msubsw) },
5983 
  { SH64_MEDIA_INSN_MULSL, SEM_FN_NAME (sh64_media,mulsl) },
5984 
  { SH64_MEDIA_INSN_MULUL, SEM_FN_NAME (sh64_media,mulul) },
5985 
  { SH64_MEDIA_INSN_NOP, SEM_FN_NAME (sh64_media,nop) },
5986 
  { SH64_MEDIA_INSN_NSB, SEM_FN_NAME (sh64_media,nsb) },
5987 
  { SH64_MEDIA_INSN_OCBI, SEM_FN_NAME (sh64_media,ocbi) },
5988 
  { SH64_MEDIA_INSN_OCBP, SEM_FN_NAME (sh64_media,ocbp) },
5989 
  { SH64_MEDIA_INSN_OCBWB, SEM_FN_NAME (sh64_media,ocbwb) },
5990 
  { SH64_MEDIA_INSN_OR, SEM_FN_NAME (sh64_media,or) },
5991 
  { SH64_MEDIA_INSN_ORI, SEM_FN_NAME (sh64_media,ori) },
5992 
  { SH64_MEDIA_INSN_PREFI, SEM_FN_NAME (sh64_media,prefi) },
5993 
  { SH64_MEDIA_INSN_PTA, SEM_FN_NAME (sh64_media,pta) },
5994 
  { SH64_MEDIA_INSN_PTABS, SEM_FN_NAME (sh64_media,ptabs) },
5995 
  { SH64_MEDIA_INSN_PTB, SEM_FN_NAME (sh64_media,ptb) },
5996 
  { SH64_MEDIA_INSN_PTREL, SEM_FN_NAME (sh64_media,ptrel) },
5997 
  { SH64_MEDIA_INSN_PUTCFG, SEM_FN_NAME (sh64_media,putcfg) },
5998 
  { SH64_MEDIA_INSN_PUTCON, SEM_FN_NAME (sh64_media,putcon) },
5999 
  { SH64_MEDIA_INSN_RTE, SEM_FN_NAME (sh64_media,rte) },
6000 
  { SH64_MEDIA_INSN_SHARD, SEM_FN_NAME (sh64_media,shard) },
6001 
  { SH64_MEDIA_INSN_SHARDL, SEM_FN_NAME (sh64_media,shardl) },
6002 
  { SH64_MEDIA_INSN_SHARI, SEM_FN_NAME (sh64_media,shari) },
6003 
  { SH64_MEDIA_INSN_SHARIL, SEM_FN_NAME (sh64_media,sharil) },
6004 
  { SH64_MEDIA_INSN_SHLLD, SEM_FN_NAME (sh64_media,shlld) },
6005 
  { SH64_MEDIA_INSN_SHLLDL, SEM_FN_NAME (sh64_media,shlldl) },
6006 
  { SH64_MEDIA_INSN_SHLLI, SEM_FN_NAME (sh64_media,shlli) },
6007 
  { SH64_MEDIA_INSN_SHLLIL, SEM_FN_NAME (sh64_media,shllil) },
6008 
  { SH64_MEDIA_INSN_SHLRD, SEM_FN_NAME (sh64_media,shlrd) },
6009 
  { SH64_MEDIA_INSN_SHLRDL, SEM_FN_NAME (sh64_media,shlrdl) },
6010 
  { SH64_MEDIA_INSN_SHLRI, SEM_FN_NAME (sh64_media,shlri) },
6011 
  { SH64_MEDIA_INSN_SHLRIL, SEM_FN_NAME (sh64_media,shlril) },
6012 
  { SH64_MEDIA_INSN_SHORI, SEM_FN_NAME (sh64_media,shori) },
6013 
  { SH64_MEDIA_INSN_SLEEP, SEM_FN_NAME (sh64_media,sleep) },
6014 
  { SH64_MEDIA_INSN_STB, SEM_FN_NAME (sh64_media,stb) },
6015 
  { SH64_MEDIA_INSN_STL, SEM_FN_NAME (sh64_media,stl) },
6016 
  { SH64_MEDIA_INSN_STQ, SEM_FN_NAME (sh64_media,stq) },
6017 
  { SH64_MEDIA_INSN_STW, SEM_FN_NAME (sh64_media,stw) },
6018 
  { SH64_MEDIA_INSN_STHIL, SEM_FN_NAME (sh64_media,sthil) },
6019 
  { SH64_MEDIA_INSN_STHIQ, SEM_FN_NAME (sh64_media,sthiq) },
6020 
  { SH64_MEDIA_INSN_STLOL, SEM_FN_NAME (sh64_media,stlol) },
6021 
  { SH64_MEDIA_INSN_STLOQ, SEM_FN_NAME (sh64_media,stloq) },
6022 
  { SH64_MEDIA_INSN_STXB, SEM_FN_NAME (sh64_media,stxb) },
6023 
  { SH64_MEDIA_INSN_STXL, SEM_FN_NAME (sh64_media,stxl) },
6024 
  { SH64_MEDIA_INSN_STXQ, SEM_FN_NAME (sh64_media,stxq) },
6025 
  { SH64_MEDIA_INSN_STXW, SEM_FN_NAME (sh64_media,stxw) },
6026 
  { SH64_MEDIA_INSN_SUB, SEM_FN_NAME (sh64_media,sub) },
6027 
  { SH64_MEDIA_INSN_SUBL, SEM_FN_NAME (sh64_media,subl) },
6028 
  { SH64_MEDIA_INSN_SWAPQ, SEM_FN_NAME (sh64_media,swapq) },
6029 
  { SH64_MEDIA_INSN_SYNCI, SEM_FN_NAME (sh64_media,synci) },
6030 
  { SH64_MEDIA_INSN_SYNCO, SEM_FN_NAME (sh64_media,synco) },
6031 
  { SH64_MEDIA_INSN_TRAPA, SEM_FN_NAME (sh64_media,trapa) },
6032 
  { SH64_MEDIA_INSN_XOR, SEM_FN_NAME (sh64_media,xor) },
6033 
  { SH64_MEDIA_INSN_XORI, SEM_FN_NAME (sh64_media,xori) },
6034 
  { 0, 0 }
6035 
};
6036 
 
6037 
/* Add the semantic fns to IDESC_TABLE.  */
6038 
 
6039 
void
6040 
SEM_FN_NAME (sh64_media,init_idesc_table) (SIM_CPU *current_cpu)
6041 
{
6042 
  IDESC *idesc_table = CPU_IDESC (current_cpu);
6043 
  const struct sem_fn_desc *sf;
6044 
  int mach_num = MACH_NUM (CPU_MACH (current_cpu));
6045 
 
6046 
  for (sf = &sem_fns[0]; sf->fn != 0; ++sf)
6047 
    {
6048 
      const CGEN_INSN *insn = idesc_table[sf->index].idata;
6049 
      int valid_p = (CGEN_INSN_VIRTUAL_P (insn)
6050 
                     || CGEN_INSN_MACH_HAS_P (insn, mach_num));
6051 
#if FAST_P
6052 
      if (valid_p)
6053 
        idesc_table[sf->index].sem_fast = sf->fn;
6054 
      else
6055 
        idesc_table[sf->index].sem_fast = SEM_FN_NAME (sh64_media,x_invalid);
6056 
#else
6057 
      if (valid_p)
6058 
        idesc_table[sf->index].sem_full = sf->fn;
6059 
      else
6060 
        idesc_table[sf->index].sem_full = SEM_FN_NAME (sh64_media,x_invalid);
6061 
#endif
6062 
    }
6063 
}
6064 
 

powered by: WebSVN 2.1.0

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