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