sim/m32r/sem.c

   1 /* Simulator instruction semantics for m32rbf.
   2
   3 THIS FILE IS MACHINE GENERATED WITH CGEN.
   4
   5 Copyright 1996-2013 Free Software Foundation, Inc.
   6
   7 This file is part of the GNU simulators.
   8
   9    This file is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3, or (at your option)
  12    any later version.
  13
  14    It is distributed in the hope that it will be useful, but WITHOUT
  15    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  16    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  17    License for more details.
  18
  19    You should have received a copy of the GNU General Public License along
  20    with this program; if not, see <http://www.gnu.org/licenses/>.
  21
  22 */
  23
  24 #define WANT_CPU m32rbf
  25 #define WANT_CPU_M32RBF
  26
  27 #include "sim-main.h"
  28 #include "cgen-mem.h"
  29 #include "cgen-ops.h"
  30
  31 #undef GET_ATTR
  32 #define GET_ATTR(cpu, num, attr) CGEN_ATTR_VALUE (NULL, abuf->idesc->attrs, CGEN_INSN_##attr)
  33
  34 /* This is used so that we can compile two copies of the semantic code,
  35    one with full feature support and one without that runs fast(er).
  36    FAST_P, when desired, is defined on the command line, -DFAST_P=1.  */
  37 #if FAST_P
  38 #define SEM_FN_NAME(cpu,fn) XCONCAT3 (cpu,_semf_,fn)
  39 #undef TRACE_RESULT
  40 #define TRACE_RESULT(cpu, abuf, name, type, val)
  41 #else
  42 #define SEM_FN_NAME(cpu,fn) XCONCAT3 (cpu,_sem_,fn)
  43 #endif
  44
  45 /* x-invalid: --invalid-- */
  46
  47 static SEM_PC
  48 SEM_FN_NAME (m32rbf,x_invalid) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
  49 {
  50 #define FLD(f) abuf->fields.sfmt_empty.f
  51   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
  52   int UNUSED written = 0;
  53   IADDR UNUSED pc = abuf->addr;
  54   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
  55
  56   {
  57     /* Update the recorded pc in the cpu state struct.
  58        Only necessary for WITH_SCACHE case, but to avoid the
  59        conditional compilation ....  */
  60     SET_H_PC (pc);
  61     /* Virtual insns have zero size.  Overwrite vpc with address of next insn
  62        using the default-insn-bitsize spec.  When executing insns in parallel
  63        we may want to queue the fault and continue execution.  */
  64     vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
  65     vpc = sim_engine_invalid_insn (current_cpu, pc, vpc);
  66   }
  67
  68   return vpc;
  69 #undef FLD
  70 }
  71
  72 /* x-after: --after-- */
  73
  74 static SEM_PC
  75 SEM_FN_NAME (m32rbf,x_after) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
  76 {
  77 #define FLD(f) abuf->fields.sfmt_empty.f
  78   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
  79   int UNUSED written = 0;
  80   IADDR UNUSED pc = abuf->addr;
  81   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
  82
  83   {
  84 #if WITH_SCACHE_PBB_M32RBF
  85     m32rbf_pbb_after (current_cpu, sem_arg);
  86 #endif
  87   }
  88
  89   return vpc;
  90 #undef FLD
  91 }
  92
  93 /* x-before: --before-- */
  94
  95 static SEM_PC
  96 SEM_FN_NAME (m32rbf,x_before) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
  97 {
  98 #define FLD(f) abuf->fields.sfmt_empty.f
  99   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 100   int UNUSED written = 0;
 101   IADDR UNUSED pc = abuf->addr;
 102   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
 103
 104   {
 105 #if WITH_SCACHE_PBB_M32RBF
 106     m32rbf_pbb_before (current_cpu, sem_arg);
 107 #endif
 108   }
 109
 110   return vpc;
 111 #undef FLD
 112 }
 113
 114 /* x-cti-chain: --cti-chain-- */
 115
 116 static SEM_PC
 117 SEM_FN_NAME (m32rbf,x_cti_chain) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 118 {
 119 #define FLD(f) abuf->fields.sfmt_empty.f
 120   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 121   int UNUSED written = 0;
 122   IADDR UNUSED pc = abuf->addr;
 123   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
 124
 125   {
 126 #if WITH_SCACHE_PBB_M32RBF
 127 #ifdef DEFINE_SWITCH
 128     vpc = m32rbf_pbb_cti_chain (current_cpu, sem_arg,
 129                                pbb_br_type, pbb_br_npc);
 130     BREAK (sem);
 131 #else
 132     /* FIXME: Allow provision of explicit ifmt spec in insn spec.  */
 133     vpc = m32rbf_pbb_cti_chain (current_cpu, sem_arg,
 134                                CPU_PBB_BR_TYPE (current_cpu),
 135                                CPU_PBB_BR_NPC (current_cpu));
 136 #endif
 137 #endif
 138   }
 139
 140   return vpc;
 141 #undef FLD
 142 }
 143
 144 /* x-chain: --chain-- */
 145
 146 static SEM_PC
 147 SEM_FN_NAME (m32rbf,x_chain) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 148 {
 149 #define FLD(f) abuf->fields.sfmt_empty.f
 150   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 151   int UNUSED written = 0;
 152   IADDR UNUSED pc = abuf->addr;
 153   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
 154
 155   {
 156 #if WITH_SCACHE_PBB_M32RBF
 157     vpc = m32rbf_pbb_chain (current_cpu, sem_arg);
 158 #ifdef DEFINE_SWITCH
 159     BREAK (sem);
 160 #endif
 161 #endif
 162   }
 163
 164   return vpc;
 165 #undef FLD
 166 }
 167
 168 /* x-begin: --begin-- */
 169
 170 static SEM_PC
 171 SEM_FN_NAME (m32rbf,x_begin) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 172 {
 173 #define FLD(f) abuf->fields.sfmt_empty.f
 174   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 175   int UNUSED written = 0;
 176   IADDR UNUSED pc = abuf->addr;
 177   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
 178
 179   {
 180 #if WITH_SCACHE_PBB_M32RBF
 181 #if defined DEFINE_SWITCH || defined FAST_P
 182     /* In the switch case FAST_P is a constant, allowing several optimizations
 183        in any called inline functions.  */
 184     vpc = m32rbf_pbb_begin (current_cpu, FAST_P);
 185 #else
 186 #if 0 /* cgen engine can't handle dynamic fast/full switching yet.  */
 187     vpc = m32rbf_pbb_begin (current_cpu, STATE_RUN_FAST_P (CPU_STATE (current_cpu)));
 188 #else
 189     vpc = m32rbf_pbb_begin (current_cpu, 0);
 190 #endif
 191 #endif
 192 #endif
 193   }
 194
 195   return vpc;
 196 #undef FLD
 197 }
 198
 199 /* add: add $dr,$sr */
 200
 201 static SEM_PC
 202 SEM_FN_NAME (m32rbf,add) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 203 {
 204 #define FLD(f) abuf->fields.sfmt_add.f
 205   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 206   int UNUSED written = 0;
 207   IADDR UNUSED pc = abuf->addr;
 208   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 209
 210   {
 211     SI opval = ADDSI (* FLD (i_dr), * FLD (i_sr));
 212     * FLD (i_dr) = opval;
 213     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 214   }
 215
 216   return vpc;
 217 #undef FLD
 218 }
 219
 220 /* add3: add3 $dr,$sr,$hash$slo16 */
 221
 222 static SEM_PC
 223 SEM_FN_NAME (m32rbf,add3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 224 {
 225 #define FLD(f) abuf->fields.sfmt_add3.f
 226   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 227   int UNUSED written = 0;
 228   IADDR UNUSED pc = abuf->addr;
 229   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 230
 231   {
 232     SI opval = ADDSI (* FLD (i_sr), FLD (f_simm16));
 233     * FLD (i_dr) = opval;
 234     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 235   }
 236
 237   return vpc;
 238 #undef FLD
 239 }
 240
 241 /* and: and $dr,$sr */
 242
 243 static SEM_PC
 244 SEM_FN_NAME (m32rbf,and) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 245 {
 246 #define FLD(f) abuf->fields.sfmt_add.f
 247   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 248   int UNUSED written = 0;
 249   IADDR UNUSED pc = abuf->addr;
 250   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 251
 252   {
 253     SI opval = ANDSI (* FLD (i_dr), * FLD (i_sr));
 254     * FLD (i_dr) = opval;
 255     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 256   }
 257
 258   return vpc;
 259 #undef FLD
 260 }
 261
 262 /* and3: and3 $dr,$sr,$uimm16 */
 263
 264 static SEM_PC
 265 SEM_FN_NAME (m32rbf,and3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 266 {
 267 #define FLD(f) abuf->fields.sfmt_and3.f
 268   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 269   int UNUSED written = 0;
 270   IADDR UNUSED pc = abuf->addr;
 271   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 272
 273   {
 274     SI opval = ANDSI (* FLD (i_sr), FLD (f_uimm16));
 275     * FLD (i_dr) = opval;
 276     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 277   }
 278
 279   return vpc;
 280 #undef FLD
 281 }
 282
 283 /* or: or $dr,$sr */
 284
 285 static SEM_PC
 286 SEM_FN_NAME (m32rbf,or) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 287 {
 288 #define FLD(f) abuf->fields.sfmt_add.f
 289   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 290   int UNUSED written = 0;
 291   IADDR UNUSED pc = abuf->addr;
 292   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 293
 294   {
 295     SI opval = ORSI (* FLD (i_dr), * FLD (i_sr));
 296     * FLD (i_dr) = opval;
 297     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 298   }
 299
 300   return vpc;
 301 #undef FLD
 302 }
 303
 304 /* or3: or3 $dr,$sr,$hash$ulo16 */
 305
 306 static SEM_PC
 307 SEM_FN_NAME (m32rbf,or3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 308 {
 309 #define FLD(f) abuf->fields.sfmt_and3.f
 310   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 311   int UNUSED written = 0;
 312   IADDR UNUSED pc = abuf->addr;
 313   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 314
 315   {
 316     SI opval = ORSI (* FLD (i_sr), FLD (f_uimm16));
 317     * FLD (i_dr) = opval;
 318     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 319   }
 320
 321   return vpc;
 322 #undef FLD
 323 }
 324
 325 /* xor: xor $dr,$sr */
 326
 327 static SEM_PC
 328 SEM_FN_NAME (m32rbf,xor) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 329 {
 330 #define FLD(f) abuf->fields.sfmt_add.f
 331   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 332   int UNUSED written = 0;
 333   IADDR UNUSED pc = abuf->addr;
 334   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 335
 336   {
 337     SI opval = XORSI (* FLD (i_dr), * FLD (i_sr));
 338     * FLD (i_dr) = opval;
 339     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 340   }
 341
 342   return vpc;
 343 #undef FLD
 344 }
 345
 346 /* xor3: xor3 $dr,$sr,$uimm16 */
 347
 348 static SEM_PC
 349 SEM_FN_NAME (m32rbf,xor3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 350 {
 351 #define FLD(f) abuf->fields.sfmt_and3.f
 352   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 353   int UNUSED written = 0;
 354   IADDR UNUSED pc = abuf->addr;
 355   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 356
 357   {
 358     SI opval = XORSI (* FLD (i_sr), FLD (f_uimm16));
 359     * FLD (i_dr) = opval;
 360     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 361   }
 362
 363   return vpc;
 364 #undef FLD
 365 }
 366
 367 /* addi: addi $dr,$simm8 */
 368
 369 static SEM_PC
 370 SEM_FN_NAME (m32rbf,addi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 371 {
 372 #define FLD(f) abuf->fields.sfmt_addi.f
 373   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 374   int UNUSED written = 0;
 375   IADDR UNUSED pc = abuf->addr;
 376   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 377
 378   {
 379     SI opval = ADDSI (* FLD (i_dr), FLD (f_simm8));
 380     * FLD (i_dr) = opval;
 381     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 382   }
 383
 384   return vpc;
 385 #undef FLD
 386 }
 387
 388 /* addv: addv $dr,$sr */
 389
 390 static SEM_PC
 391 SEM_FN_NAME (m32rbf,addv) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 392 {
 393 #define FLD(f) abuf->fields.sfmt_add.f
 394   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 395   int UNUSED written = 0;
 396   IADDR UNUSED pc = abuf->addr;
 397   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 398
 399 {
 400   SI temp0;BI temp1;
 401   temp0 = ADDSI (* FLD (i_dr), * FLD (i_sr));
 402   temp1 = ADDOFSI (* FLD (i_dr), * FLD (i_sr), 0);
 403   {
 404     SI opval = temp0;
 405     * FLD (i_dr) = opval;
 406     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 407   }
 408   {
 409     BI opval = temp1;
 410     CPU (h_cond) = opval;
 411     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
 412   }
 413 }
 414
 415   return vpc;
 416 #undef FLD
 417 }
 418
 419 /* addv3: addv3 $dr,$sr,$simm16 */
 420
 421 static SEM_PC
 422 SEM_FN_NAME (m32rbf,addv3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 423 {
 424 #define FLD(f) abuf->fields.sfmt_add3.f
 425   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 426   int UNUSED written = 0;
 427   IADDR UNUSED pc = abuf->addr;
 428   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 429
 430 {
 431   SI temp0;BI temp1;
 432   temp0 = ADDSI (* FLD (i_sr), FLD (f_simm16));
 433   temp1 = ADDOFSI (* FLD (i_sr), FLD (f_simm16), 0);
 434   {
 435     SI opval = temp0;
 436     * FLD (i_dr) = opval;
 437     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 438   }
 439   {
 440     BI opval = temp1;
 441     CPU (h_cond) = opval;
 442     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
 443   }
 444 }
 445
 446   return vpc;
 447 #undef FLD
 448 }
 449
 450 /* addx: addx $dr,$sr */
 451
 452 static SEM_PC
 453 SEM_FN_NAME (m32rbf,addx) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 454 {
 455 #define FLD(f) abuf->fields.sfmt_add.f
 456   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 457   int UNUSED written = 0;
 458   IADDR UNUSED pc = abuf->addr;
 459   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 460
 461 {
 462   SI temp0;BI temp1;
 463   temp0 = ADDCSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
 464   temp1 = ADDCFSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
 465   {
 466     SI opval = temp0;
 467     * FLD (i_dr) = opval;
 468     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 469   }
 470   {
 471     BI opval = temp1;
 472     CPU (h_cond) = opval;
 473     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
 474   }
 475 }
 476
 477   return vpc;
 478 #undef FLD
 479 }
 480
 481 /* bc8: bc.s $disp8 */
 482
 483 static SEM_PC
 484 SEM_FN_NAME (m32rbf,bc8) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 485 {
 486 #define FLD(f) abuf->fields.sfmt_bl8.f
 487   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 488   int UNUSED written = 0;
 489   IADDR UNUSED pc = abuf->addr;
 490   SEM_BRANCH_INIT
 491   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 492
 493 if (CPU (h_cond)) {
 494   {
 495     USI opval = FLD (i_disp8);
 496     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 497     written |= (1 << 2);
 498     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 499   }
 500 }
 501
 502   abuf->written = written;
 503   SEM_BRANCH_FINI (vpc);
 504   return vpc;
 505 #undef FLD
 506 }
 507
 508 /* bc24: bc.l $disp24 */
 509
 510 static SEM_PC
 511 SEM_FN_NAME (m32rbf,bc24) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 512 {
 513 #define FLD(f) abuf->fields.sfmt_bl24.f
 514   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 515   int UNUSED written = 0;
 516   IADDR UNUSED pc = abuf->addr;
 517   SEM_BRANCH_INIT
 518   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 519
 520 if (CPU (h_cond)) {
 521   {
 522     USI opval = FLD (i_disp24);
 523     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 524     written |= (1 << 2);
 525     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 526   }
 527 }
 528
 529   abuf->written = written;
 530   SEM_BRANCH_FINI (vpc);
 531   return vpc;
 532 #undef FLD
 533 }
 534
 535 /* beq: beq $src1,$src2,$disp16 */
 536
 537 static SEM_PC
 538 SEM_FN_NAME (m32rbf,beq) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 539 {
 540 #define FLD(f) abuf->fields.sfmt_beq.f
 541   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 542   int UNUSED written = 0;
 543   IADDR UNUSED pc = abuf->addr;
 544   SEM_BRANCH_INIT
 545   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 546
 547 if (EQSI (* FLD (i_src1), * FLD (i_src2))) {
 548   {
 549     USI opval = FLD (i_disp16);
 550     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 551     written |= (1 << 3);
 552     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 553   }
 554 }
 555
 556   abuf->written = written;
 557   SEM_BRANCH_FINI (vpc);
 558   return vpc;
 559 #undef FLD
 560 }
 561
 562 /* beqz: beqz $src2,$disp16 */
 563
 564 static SEM_PC
 565 SEM_FN_NAME (m32rbf,beqz) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 566 {
 567 #define FLD(f) abuf->fields.sfmt_beq.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, 4);
 573
 574 if (EQSI (* FLD (i_src2), 0)) {
 575   {
 576     USI opval = FLD (i_disp16);
 577     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 578     written |= (1 << 2);
 579     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 580   }
 581 }
 582
 583   abuf->written = written;
 584   SEM_BRANCH_FINI (vpc);
 585   return vpc;
 586 #undef FLD
 587 }
 588
 589 /* bgez: bgez $src2,$disp16 */
 590
 591 static SEM_PC
 592 SEM_FN_NAME (m32rbf,bgez) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 593 {
 594 #define FLD(f) abuf->fields.sfmt_beq.f
 595   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 596   int UNUSED written = 0;
 597   IADDR UNUSED pc = abuf->addr;
 598   SEM_BRANCH_INIT
 599   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 600
 601 if (GESI (* FLD (i_src2), 0)) {
 602   {
 603     USI opval = FLD (i_disp16);
 604     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 605     written |= (1 << 2);
 606     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 607   }
 608 }
 609
 610   abuf->written = written;
 611   SEM_BRANCH_FINI (vpc);
 612   return vpc;
 613 #undef FLD
 614 }
 615
 616 /* bgtz: bgtz $src2,$disp16 */
 617
 618 static SEM_PC
 619 SEM_FN_NAME (m32rbf,bgtz) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 620 {
 621 #define FLD(f) abuf->fields.sfmt_beq.f
 622   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 623   int UNUSED written = 0;
 624   IADDR UNUSED pc = abuf->addr;
 625   SEM_BRANCH_INIT
 626   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 627
 628 if (GTSI (* FLD (i_src2), 0)) {
 629   {
 630     USI opval = FLD (i_disp16);
 631     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 632     written |= (1 << 2);
 633     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 634   }
 635 }
 636
 637   abuf->written = written;
 638   SEM_BRANCH_FINI (vpc);
 639   return vpc;
 640 #undef FLD
 641 }
 642
 643 /* blez: blez $src2,$disp16 */
 644
 645 static SEM_PC
 646 SEM_FN_NAME (m32rbf,blez) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 647 {
 648 #define FLD(f) abuf->fields.sfmt_beq.f
 649   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 650   int UNUSED written = 0;
 651   IADDR UNUSED pc = abuf->addr;
 652   SEM_BRANCH_INIT
 653   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 654
 655 if (LESI (* FLD (i_src2), 0)) {
 656   {
 657     USI opval = FLD (i_disp16);
 658     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 659     written |= (1 << 2);
 660     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 661   }
 662 }
 663
 664   abuf->written = written;
 665   SEM_BRANCH_FINI (vpc);
 666   return vpc;
 667 #undef FLD
 668 }
 669
 670 /* bltz: bltz $src2,$disp16 */
 671
 672 static SEM_PC
 673 SEM_FN_NAME (m32rbf,bltz) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 674 {
 675 #define FLD(f) abuf->fields.sfmt_beq.f
 676   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 677   int UNUSED written = 0;
 678   IADDR UNUSED pc = abuf->addr;
 679   SEM_BRANCH_INIT
 680   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 681
 682 if (LTSI (* FLD (i_src2), 0)) {
 683   {
 684     USI opval = FLD (i_disp16);
 685     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 686     written |= (1 << 2);
 687     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 688   }
 689 }
 690
 691   abuf->written = written;
 692   SEM_BRANCH_FINI (vpc);
 693   return vpc;
 694 #undef FLD
 695 }
 696
 697 /* bnez: bnez $src2,$disp16 */
 698
 699 static SEM_PC
 700 SEM_FN_NAME (m32rbf,bnez) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 701 {
 702 #define FLD(f) abuf->fields.sfmt_beq.f
 703   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 704   int UNUSED written = 0;
 705   IADDR UNUSED pc = abuf->addr;
 706   SEM_BRANCH_INIT
 707   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 708
 709 if (NESI (* FLD (i_src2), 0)) {
 710   {
 711     USI opval = FLD (i_disp16);
 712     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 713     written |= (1 << 2);
 714     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 715   }
 716 }
 717
 718   abuf->written = written;
 719   SEM_BRANCH_FINI (vpc);
 720   return vpc;
 721 #undef FLD
 722 }
 723
 724 /* bl8: bl.s $disp8 */
 725
 726 static SEM_PC
 727 SEM_FN_NAME (m32rbf,bl8) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 728 {
 729 #define FLD(f) abuf->fields.sfmt_bl8.f
 730   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 731   int UNUSED written = 0;
 732   IADDR UNUSED pc = abuf->addr;
 733   SEM_BRANCH_INIT
 734   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 735
 736 {
 737   {
 738     SI opval = ADDSI (ANDSI (pc, -4), 4);
 739     CPU (h_gr[((UINT) 14)]) = opval;
 740     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 741   }
 742   {
 743     USI opval = FLD (i_disp8);
 744     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 745     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 746   }
 747 }
 748
 749   SEM_BRANCH_FINI (vpc);
 750   return vpc;
 751 #undef FLD
 752 }
 753
 754 /* bl24: bl.l $disp24 */
 755
 756 static SEM_PC
 757 SEM_FN_NAME (m32rbf,bl24) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 758 {
 759 #define FLD(f) abuf->fields.sfmt_bl24.f
 760   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 761   int UNUSED written = 0;
 762   IADDR UNUSED pc = abuf->addr;
 763   SEM_BRANCH_INIT
 764   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 765
 766 {
 767   {
 768     SI opval = ADDSI (pc, 4);
 769     CPU (h_gr[((UINT) 14)]) = opval;
 770     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 771   }
 772   {
 773     USI opval = FLD (i_disp24);
 774     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 775     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 776   }
 777 }
 778
 779   SEM_BRANCH_FINI (vpc);
 780   return vpc;
 781 #undef FLD
 782 }
 783
 784 /* bnc8: bnc.s $disp8 */
 785
 786 static SEM_PC
 787 SEM_FN_NAME (m32rbf,bnc8) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 788 {
 789 #define FLD(f) abuf->fields.sfmt_bl8.f
 790   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 791   int UNUSED written = 0;
 792   IADDR UNUSED pc = abuf->addr;
 793   SEM_BRANCH_INIT
 794   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 795
 796 if (NOTBI (CPU (h_cond))) {
 797   {
 798     USI opval = FLD (i_disp8);
 799     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 800     written |= (1 << 2);
 801     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 802   }
 803 }
 804
 805   abuf->written = written;
 806   SEM_BRANCH_FINI (vpc);
 807   return vpc;
 808 #undef FLD
 809 }
 810
 811 /* bnc24: bnc.l $disp24 */
 812
 813 static SEM_PC
 814 SEM_FN_NAME (m32rbf,bnc24) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 815 {
 816 #define FLD(f) abuf->fields.sfmt_bl24.f
 817   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 818   int UNUSED written = 0;
 819   IADDR UNUSED pc = abuf->addr;
 820   SEM_BRANCH_INIT
 821   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 822
 823 if (NOTBI (CPU (h_cond))) {
 824   {
 825     USI opval = FLD (i_disp24);
 826     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 827     written |= (1 << 2);
 828     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 829   }
 830 }
 831
 832   abuf->written = written;
 833   SEM_BRANCH_FINI (vpc);
 834   return vpc;
 835 #undef FLD
 836 }
 837
 838 /* bne: bne $src1,$src2,$disp16 */
 839
 840 static SEM_PC
 841 SEM_FN_NAME (m32rbf,bne) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 842 {
 843 #define FLD(f) abuf->fields.sfmt_beq.f
 844   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 845   int UNUSED written = 0;
 846   IADDR UNUSED pc = abuf->addr;
 847   SEM_BRANCH_INIT
 848   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 849
 850 if (NESI (* FLD (i_src1), * FLD (i_src2))) {
 851   {
 852     USI opval = FLD (i_disp16);
 853     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 854     written |= (1 << 3);
 855     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 856   }
 857 }
 858
 859   abuf->written = written;
 860   SEM_BRANCH_FINI (vpc);
 861   return vpc;
 862 #undef FLD
 863 }
 864
 865 /* bra8: bra.s $disp8 */
 866
 867 static SEM_PC
 868 SEM_FN_NAME (m32rbf,bra8) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 869 {
 870 #define FLD(f) abuf->fields.sfmt_bl8.f
 871   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 872   int UNUSED written = 0;
 873   IADDR UNUSED pc = abuf->addr;
 874   SEM_BRANCH_INIT
 875   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 876
 877   {
 878     USI opval = FLD (i_disp8);
 879     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 880     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 881   }
 882
 883   SEM_BRANCH_FINI (vpc);
 884   return vpc;
 885 #undef FLD
 886 }
 887
 888 /* bra24: bra.l $disp24 */
 889
 890 static SEM_PC
 891 SEM_FN_NAME (m32rbf,bra24) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 892 {
 893 #define FLD(f) abuf->fields.sfmt_bl24.f
 894   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 895   int UNUSED written = 0;
 896   IADDR UNUSED pc = abuf->addr;
 897   SEM_BRANCH_INIT
 898   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 899
 900   {
 901     USI opval = FLD (i_disp24);
 902     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 903     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 904   }
 905
 906   SEM_BRANCH_FINI (vpc);
 907   return vpc;
 908 #undef FLD
 909 }
 910
 911 /* cmp: cmp $src1,$src2 */
 912
 913 static SEM_PC
 914 SEM_FN_NAME (m32rbf,cmp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 915 {
 916 #define FLD(f) abuf->fields.sfmt_st_plus.f
 917   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 918   int UNUSED written = 0;
 919   IADDR UNUSED pc = abuf->addr;
 920   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 921
 922   {
 923     BI opval = LTSI (* FLD (i_src1), * FLD (i_src2));
 924     CPU (h_cond) = opval;
 925     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
 926   }
 927
 928   return vpc;
 929 #undef FLD
 930 }
 931
 932 /* cmpi: cmpi $src2,$simm16 */
 933
 934 static SEM_PC
 935 SEM_FN_NAME (m32rbf,cmpi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 936 {
 937 #define FLD(f) abuf->fields.sfmt_st_d.f
 938   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 939   int UNUSED written = 0;
 940   IADDR UNUSED pc = abuf->addr;
 941   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 942
 943   {
 944     BI opval = LTSI (* FLD (i_src2), FLD (f_simm16));
 945     CPU (h_cond) = opval;
 946     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
 947   }
 948
 949   return vpc;
 950 #undef FLD
 951 }
 952
 953 /* cmpu: cmpu $src1,$src2 */
 954
 955 static SEM_PC
 956 SEM_FN_NAME (m32rbf,cmpu) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 957 {
 958 #define FLD(f) abuf->fields.sfmt_st_plus.f
 959   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 960   int UNUSED written = 0;
 961   IADDR UNUSED pc = abuf->addr;
 962   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 963
 964   {
 965     BI opval = LTUSI (* FLD (i_src1), * FLD (i_src2));
 966     CPU (h_cond) = opval;
 967     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
 968   }
 969
 970   return vpc;
 971 #undef FLD
 972 }
 973
 974 /* cmpui: cmpui $src2,$simm16 */
 975
 976 static SEM_PC
 977 SEM_FN_NAME (m32rbf,cmpui) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 978 {
 979 #define FLD(f) abuf->fields.sfmt_st_d.f
 980   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 981   int UNUSED written = 0;
 982   IADDR UNUSED pc = abuf->addr;
 983   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 984
 985   {
 986     BI opval = LTUSI (* FLD (i_src2), FLD (f_simm16));
 987     CPU (h_cond) = opval;
 988     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
 989   }
 990
 991   return vpc;
 992 #undef FLD
 993 }
 994
 995 /* div: div $dr,$sr */
 996
 997 static SEM_PC
 998 SEM_FN_NAME (m32rbf,div) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 999 {
1000 #define FLD(f) abuf->fields.sfmt_add.f
1001   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1002   int UNUSED written = 0;
1003   IADDR UNUSED pc = abuf->addr;
1004   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1005
1006 if (NESI (* FLD (i_sr), 0)) {
1007   {
1008     SI opval = DIVSI (* FLD (i_dr), * FLD (i_sr));
1009     * FLD (i_dr) = opval;
1010     written |= (1 << 2);
1011     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1012   }
1013 }
1014
1015   abuf->written = written;
1016   return vpc;
1017 #undef FLD
1018 }
1019
1020 /* divu: divu $dr,$sr */
1021
1022 static SEM_PC
1023 SEM_FN_NAME (m32rbf,divu) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1024 {
1025 #define FLD(f) abuf->fields.sfmt_add.f
1026   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1027   int UNUSED written = 0;
1028   IADDR UNUSED pc = abuf->addr;
1029   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1030
1031 if (NESI (* FLD (i_sr), 0)) {
1032   {
1033     SI opval = UDIVSI (* FLD (i_dr), * FLD (i_sr));
1034     * FLD (i_dr) = opval;
1035     written |= (1 << 2);
1036     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1037   }
1038 }
1039
1040   abuf->written = written;
1041   return vpc;
1042 #undef FLD
1043 }
1044
1045 /* rem: rem $dr,$sr */
1046
1047 static SEM_PC
1048 SEM_FN_NAME (m32rbf,rem) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1049 {
1050 #define FLD(f) abuf->fields.sfmt_add.f
1051   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1052   int UNUSED written = 0;
1053   IADDR UNUSED pc = abuf->addr;
1054   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1055
1056 if (NESI (* FLD (i_sr), 0)) {
1057   {
1058     SI opval = MODSI (* FLD (i_dr), * FLD (i_sr));
1059     * FLD (i_dr) = opval;
1060     written |= (1 << 2);
1061     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1062   }
1063 }
1064
1065   abuf->written = written;
1066   return vpc;
1067 #undef FLD
1068 }
1069
1070 /* remu: remu $dr,$sr */
1071
1072 static SEM_PC
1073 SEM_FN_NAME (m32rbf,remu) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1074 {
1075 #define FLD(f) abuf->fields.sfmt_add.f
1076   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1077   int UNUSED written = 0;
1078   IADDR UNUSED pc = abuf->addr;
1079   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1080
1081 if (NESI (* FLD (i_sr), 0)) {
1082   {
1083     SI opval = UMODSI (* FLD (i_dr), * FLD (i_sr));
1084     * FLD (i_dr) = opval;
1085     written |= (1 << 2);
1086     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1087   }
1088 }
1089
1090   abuf->written = written;
1091   return vpc;
1092 #undef FLD
1093 }
1094
1095 /* jl: jl $sr */
1096
1097 static SEM_PC
1098 SEM_FN_NAME (m32rbf,jl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1099 {
1100 #define FLD(f) abuf->fields.sfmt_jl.f
1101   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1102   int UNUSED written = 0;
1103   IADDR UNUSED pc = abuf->addr;
1104   SEM_BRANCH_INIT
1105   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1106
1107 {
1108   SI temp0;USI temp1;
1109   temp0 = ADDSI (ANDSI (pc, -4), 4);
1110   temp1 = ANDSI (* FLD (i_sr), -4);
1111   {
1112     SI opval = temp0;
1113     CPU (h_gr[((UINT) 14)]) = opval;
1114     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1115   }
1116   {
1117     USI opval = temp1;
1118     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
1119     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1120   }
1121 }
1122
1123   SEM_BRANCH_FINI (vpc);
1124   return vpc;
1125 #undef FLD
1126 }
1127
1128 /* jmp: jmp $sr */
1129
1130 static SEM_PC
1131 SEM_FN_NAME (m32rbf,jmp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1132 {
1133 #define FLD(f) abuf->fields.sfmt_jl.f
1134   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1135   int UNUSED written = 0;
1136   IADDR UNUSED pc = abuf->addr;
1137   SEM_BRANCH_INIT
1138   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1139
1140   {
1141     USI opval = ANDSI (* FLD (i_sr), -4);
1142     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
1143     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1144   }
1145
1146   SEM_BRANCH_FINI (vpc);
1147   return vpc;
1148 #undef FLD
1149 }
1150
1151 /* ld: ld $dr,@$sr */
1152
1153 static SEM_PC
1154 SEM_FN_NAME (m32rbf,ld) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1155 {
1156 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1157   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1158   int UNUSED written = 0;
1159   IADDR UNUSED pc = abuf->addr;
1160   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1161
1162   {
1163     SI opval = GETMEMSI (current_cpu, pc, * FLD (i_sr));
1164     * FLD (i_dr) = opval;
1165     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1166   }
1167
1168   return vpc;
1169 #undef FLD
1170 }
1171
1172 /* ld-d: ld $dr,@($slo16,$sr) */
1173
1174 static SEM_PC
1175 SEM_FN_NAME (m32rbf,ld_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1176 {
1177 #define FLD(f) abuf->fields.sfmt_add3.f
1178   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1179   int UNUSED written = 0;
1180   IADDR UNUSED pc = abuf->addr;
1181   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1182
1183   {
1184     SI opval = GETMEMSI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16)));
1185     * FLD (i_dr) = opval;
1186     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1187   }
1188
1189   return vpc;
1190 #undef FLD
1191 }
1192
1193 /* ldb: ldb $dr,@$sr */
1194
1195 static SEM_PC
1196 SEM_FN_NAME (m32rbf,ldb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1197 {
1198 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1199   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1200   int UNUSED written = 0;
1201   IADDR UNUSED pc = abuf->addr;
1202   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1203
1204   {
1205     SI opval = EXTQISI (GETMEMQI (current_cpu, pc, * FLD (i_sr)));
1206     * FLD (i_dr) = opval;
1207     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1208   }
1209
1210   return vpc;
1211 #undef FLD
1212 }
1213
1214 /* ldb-d: ldb $dr,@($slo16,$sr) */
1215
1216 static SEM_PC
1217 SEM_FN_NAME (m32rbf,ldb_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1218 {
1219 #define FLD(f) abuf->fields.sfmt_add3.f
1220   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1221   int UNUSED written = 0;
1222   IADDR UNUSED pc = abuf->addr;
1223   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1224
1225   {
1226     SI opval = EXTQISI (GETMEMQI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16))));
1227     * FLD (i_dr) = opval;
1228     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1229   }
1230
1231   return vpc;
1232 #undef FLD
1233 }
1234
1235 /* ldh: ldh $dr,@$sr */
1236
1237 static SEM_PC
1238 SEM_FN_NAME (m32rbf,ldh) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1239 {
1240 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1241   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1242   int UNUSED written = 0;
1243   IADDR UNUSED pc = abuf->addr;
1244   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1245
1246   {
1247     SI opval = EXTHISI (GETMEMHI (current_cpu, pc, * FLD (i_sr)));
1248     * FLD (i_dr) = opval;
1249     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1250   }
1251
1252   return vpc;
1253 #undef FLD
1254 }
1255
1256 /* ldh-d: ldh $dr,@($slo16,$sr) */
1257
1258 static SEM_PC
1259 SEM_FN_NAME (m32rbf,ldh_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1260 {
1261 #define FLD(f) abuf->fields.sfmt_add3.f
1262   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1263   int UNUSED written = 0;
1264   IADDR UNUSED pc = abuf->addr;
1265   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1266
1267   {
1268     SI opval = EXTHISI (GETMEMHI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16))));
1269     * FLD (i_dr) = opval;
1270     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1271   }
1272
1273   return vpc;
1274 #undef FLD
1275 }
1276
1277 /* ldub: ldub $dr,@$sr */
1278
1279 static SEM_PC
1280 SEM_FN_NAME (m32rbf,ldub) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1281 {
1282 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1283   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1284   int UNUSED written = 0;
1285   IADDR UNUSED pc = abuf->addr;
1286   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1287
1288   {
1289     SI opval = ZEXTQISI (GETMEMQI (current_cpu, pc, * FLD (i_sr)));
1290     * FLD (i_dr) = opval;
1291     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1292   }
1293
1294   return vpc;
1295 #undef FLD
1296 }
1297
1298 /* ldub-d: ldub $dr,@($slo16,$sr) */
1299
1300 static SEM_PC
1301 SEM_FN_NAME (m32rbf,ldub_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1302 {
1303 #define FLD(f) abuf->fields.sfmt_add3.f
1304   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1305   int UNUSED written = 0;
1306   IADDR UNUSED pc = abuf->addr;
1307   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1308
1309   {
1310     SI opval = ZEXTQISI (GETMEMQI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16))));
1311     * FLD (i_dr) = opval;
1312     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1313   }
1314
1315   return vpc;
1316 #undef FLD
1317 }
1318
1319 /* lduh: lduh $dr,@$sr */
1320
1321 static SEM_PC
1322 SEM_FN_NAME (m32rbf,lduh) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1323 {
1324 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1325   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1326   int UNUSED written = 0;
1327   IADDR UNUSED pc = abuf->addr;
1328   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1329
1330   {
1331     SI opval = ZEXTHISI (GETMEMHI (current_cpu, pc, * FLD (i_sr)));
1332     * FLD (i_dr) = opval;
1333     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1334   }
1335
1336   return vpc;
1337 #undef FLD
1338 }
1339
1340 /* lduh-d: lduh $dr,@($slo16,$sr) */
1341
1342 static SEM_PC
1343 SEM_FN_NAME (m32rbf,lduh_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1344 {
1345 #define FLD(f) abuf->fields.sfmt_add3.f
1346   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1347   int UNUSED written = 0;
1348   IADDR UNUSED pc = abuf->addr;
1349   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1350
1351   {
1352     SI opval = ZEXTHISI (GETMEMHI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16))));
1353     * FLD (i_dr) = opval;
1354     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1355   }
1356
1357   return vpc;
1358 #undef FLD
1359 }
1360
1361 /* ld-plus: ld $dr,@$sr+ */
1362
1363 static SEM_PC
1364 SEM_FN_NAME (m32rbf,ld_plus) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1365 {
1366 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1367   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1368   int UNUSED written = 0;
1369   IADDR UNUSED pc = abuf->addr;
1370   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1371
1372 {
1373   SI temp0;SI temp1;
1374   temp0 = GETMEMSI (current_cpu, pc, * FLD (i_sr));
1375   temp1 = ADDSI (* FLD (i_sr), 4);
1376   {
1377     SI opval = temp0;
1378     * FLD (i_dr) = opval;
1379     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1380   }
1381   {
1382     SI opval = temp1;
1383     * FLD (i_sr) = opval;
1384     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1385   }
1386 }
1387
1388   return vpc;
1389 #undef FLD
1390 }
1391
1392 /* ld24: ld24 $dr,$uimm24 */
1393
1394 static SEM_PC
1395 SEM_FN_NAME (m32rbf,ld24) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1396 {
1397 #define FLD(f) abuf->fields.sfmt_ld24.f
1398   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1399   int UNUSED written = 0;
1400   IADDR UNUSED pc = abuf->addr;
1401   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1402
1403   {
1404     SI opval = FLD (i_uimm24);
1405     * FLD (i_dr) = opval;
1406     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1407   }
1408
1409   return vpc;
1410 #undef FLD
1411 }
1412
1413 /* ldi8: ldi8 $dr,$simm8 */
1414
1415 static SEM_PC
1416 SEM_FN_NAME (m32rbf,ldi8) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1417 {
1418 #define FLD(f) abuf->fields.sfmt_addi.f
1419   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1420   int UNUSED written = 0;
1421   IADDR UNUSED pc = abuf->addr;
1422   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1423
1424   {
1425     SI opval = FLD (f_simm8);
1426     * FLD (i_dr) = opval;
1427     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1428   }
1429
1430   return vpc;
1431 #undef FLD
1432 }
1433
1434 /* ldi16: ldi16 $dr,$hash$slo16 */
1435
1436 static SEM_PC
1437 SEM_FN_NAME (m32rbf,ldi16) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1438 {
1439 #define FLD(f) abuf->fields.sfmt_add3.f
1440   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1441   int UNUSED written = 0;
1442   IADDR UNUSED pc = abuf->addr;
1443   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1444
1445   {
1446     SI opval = FLD (f_simm16);
1447     * FLD (i_dr) = opval;
1448     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1449   }
1450
1451   return vpc;
1452 #undef FLD
1453 }
1454
1455 /* lock: lock $dr,@$sr */
1456
1457 static SEM_PC
1458 SEM_FN_NAME (m32rbf,lock) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1459 {
1460 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1461   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1462   int UNUSED written = 0;
1463   IADDR UNUSED pc = abuf->addr;
1464   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1465
1466 {
1467   {
1468     BI opval = 1;
1469     CPU (h_lock) = opval;
1470     TRACE_RESULT (current_cpu, abuf, "lock", 'x', opval);
1471   }
1472   {
1473     SI opval = GETMEMSI (current_cpu, pc, * FLD (i_sr));
1474     * FLD (i_dr) = opval;
1475     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1476   }
1477 }
1478
1479   return vpc;
1480 #undef FLD
1481 }
1482
1483 /* machi: machi $src1,$src2 */
1484
1485 static SEM_PC
1486 SEM_FN_NAME (m32rbf,machi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1487 {
1488 #define FLD(f) abuf->fields.sfmt_st_plus.f
1489   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1490   int UNUSED written = 0;
1491   IADDR UNUSED pc = abuf->addr;
1492   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1493
1494   {
1495     DI opval = SRADI (SLLDI (ADDDI (GET_H_ACCUM (), MULDI (EXTSIDI (ANDSI (* FLD (i_src1), 0xffff0000)), EXTHIDI (TRUNCSIHI (SRASI (* FLD (i_src2), 16))))), 8), 8);
1496     SET_H_ACCUM (opval);
1497     TRACE_RESULT (current_cpu, abuf, "accum", 'D', opval);
1498   }
1499
1500   return vpc;
1501 #undef FLD
1502 }
1503
1504 /* maclo: maclo $src1,$src2 */
1505
1506 static SEM_PC
1507 SEM_FN_NAME (m32rbf,maclo) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1508 {
1509 #define FLD(f) abuf->fields.sfmt_st_plus.f
1510   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1511   int UNUSED written = 0;
1512   IADDR UNUSED pc = abuf->addr;
1513   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1514
1515   {
1516     DI opval = SRADI (SLLDI (ADDDI (GET_H_ACCUM (), MULDI (EXTSIDI (SLLSI (* FLD (i_src1), 16)), EXTHIDI (TRUNCSIHI (* FLD (i_src2))))), 8), 8);
1517     SET_H_ACCUM (opval);
1518     TRACE_RESULT (current_cpu, abuf, "accum", 'D', opval);
1519   }
1520
1521   return vpc;
1522 #undef FLD
1523 }
1524
1525 /* macwhi: macwhi $src1,$src2 */
1526
1527 static SEM_PC
1528 SEM_FN_NAME (m32rbf,macwhi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1529 {
1530 #define FLD(f) abuf->fields.sfmt_st_plus.f
1531   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1532   int UNUSED written = 0;
1533   IADDR UNUSED pc = abuf->addr;
1534   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1535
1536   {
1537     DI opval = SRADI (SLLDI (ADDDI (GET_H_ACCUM (), MULDI (EXTSIDI (* FLD (i_src1)), EXTHIDI (TRUNCSIHI (SRASI (* FLD (i_src2), 16))))), 8), 8);
1538     SET_H_ACCUM (opval);
1539     TRACE_RESULT (current_cpu, abuf, "accum", 'D', opval);
1540   }
1541
1542   return vpc;
1543 #undef FLD
1544 }
1545
1546 /* macwlo: macwlo $src1,$src2 */
1547
1548 static SEM_PC
1549 SEM_FN_NAME (m32rbf,macwlo) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1550 {
1551 #define FLD(f) abuf->fields.sfmt_st_plus.f
1552   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1553   int UNUSED written = 0;
1554   IADDR UNUSED pc = abuf->addr;
1555   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1556
1557   {
1558     DI opval = SRADI (SLLDI (ADDDI (GET_H_ACCUM (), MULDI (EXTSIDI (* FLD (i_src1)), EXTHIDI (TRUNCSIHI (* FLD (i_src2))))), 8), 8);
1559     SET_H_ACCUM (opval);
1560     TRACE_RESULT (current_cpu, abuf, "accum", 'D', opval);
1561   }
1562
1563   return vpc;
1564 #undef FLD
1565 }
1566
1567 /* mul: mul $dr,$sr */
1568
1569 static SEM_PC
1570 SEM_FN_NAME (m32rbf,mul) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1571 {
1572 #define FLD(f) abuf->fields.sfmt_add.f
1573   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1574   int UNUSED written = 0;
1575   IADDR UNUSED pc = abuf->addr;
1576   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1577
1578   {
1579     SI opval = MULSI (* FLD (i_dr), * FLD (i_sr));
1580     * FLD (i_dr) = opval;
1581     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1582   }
1583
1584   return vpc;
1585 #undef FLD
1586 }
1587
1588 /* mulhi: mulhi $src1,$src2 */
1589
1590 static SEM_PC
1591 SEM_FN_NAME (m32rbf,mulhi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1592 {
1593 #define FLD(f) abuf->fields.sfmt_st_plus.f
1594   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1595   int UNUSED written = 0;
1596   IADDR UNUSED pc = abuf->addr;
1597   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1598
1599   {
1600     DI opval = SRADI (SLLDI (MULDI (EXTSIDI (ANDSI (* FLD (i_src1), 0xffff0000)), EXTHIDI (TRUNCSIHI (SRASI (* FLD (i_src2), 16)))), 16), 16);
1601     SET_H_ACCUM (opval);
1602     TRACE_RESULT (current_cpu, abuf, "accum", 'D', opval);
1603   }
1604
1605   return vpc;
1606 #undef FLD
1607 }
1608
1609 /* mullo: mullo $src1,$src2 */
1610
1611 static SEM_PC
1612 SEM_FN_NAME (m32rbf,mullo) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1613 {
1614 #define FLD(f) abuf->fields.sfmt_st_plus.f
1615   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1616   int UNUSED written = 0;
1617   IADDR UNUSED pc = abuf->addr;
1618   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1619
1620   {
1621     DI opval = SRADI (SLLDI (MULDI (EXTSIDI (SLLSI (* FLD (i_src1), 16)), EXTHIDI (TRUNCSIHI (* FLD (i_src2)))), 16), 16);
1622     SET_H_ACCUM (opval);
1623     TRACE_RESULT (current_cpu, abuf, "accum", 'D', opval);
1624   }
1625
1626   return vpc;
1627 #undef FLD
1628 }
1629
1630 /* mulwhi: mulwhi $src1,$src2 */
1631
1632 static SEM_PC
1633 SEM_FN_NAME (m32rbf,mulwhi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1634 {
1635 #define FLD(f) abuf->fields.sfmt_st_plus.f
1636   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1637   int UNUSED written = 0;
1638   IADDR UNUSED pc = abuf->addr;
1639   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1640
1641   {
1642     DI opval = SRADI (SLLDI (MULDI (EXTSIDI (* FLD (i_src1)), EXTHIDI (TRUNCSIHI (SRASI (* FLD (i_src2), 16)))), 8), 8);
1643     SET_H_ACCUM (opval);
1644     TRACE_RESULT (current_cpu, abuf, "accum", 'D', opval);
1645   }
1646
1647   return vpc;
1648 #undef FLD
1649 }
1650
1651 /* mulwlo: mulwlo $src1,$src2 */
1652
1653 static SEM_PC
1654 SEM_FN_NAME (m32rbf,mulwlo) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1655 {
1656 #define FLD(f) abuf->fields.sfmt_st_plus.f
1657   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1658   int UNUSED written = 0;
1659   IADDR UNUSED pc = abuf->addr;
1660   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1661
1662   {
1663     DI opval = SRADI (SLLDI (MULDI (EXTSIDI (* FLD (i_src1)), EXTHIDI (TRUNCSIHI (* FLD (i_src2)))), 8), 8);
1664     SET_H_ACCUM (opval);
1665     TRACE_RESULT (current_cpu, abuf, "accum", 'D', opval);
1666   }
1667
1668   return vpc;
1669 #undef FLD
1670 }
1671
1672 /* mv: mv $dr,$sr */
1673
1674 static SEM_PC
1675 SEM_FN_NAME (m32rbf,mv) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1676 {
1677 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1678   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1679   int UNUSED written = 0;
1680   IADDR UNUSED pc = abuf->addr;
1681   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1682
1683   {
1684     SI opval = * FLD (i_sr);
1685     * FLD (i_dr) = opval;
1686     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1687   }
1688
1689   return vpc;
1690 #undef FLD
1691 }
1692
1693 /* mvfachi: mvfachi $dr */
1694
1695 static SEM_PC
1696 SEM_FN_NAME (m32rbf,mvfachi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1697 {
1698 #define FLD(f) abuf->fields.sfmt_seth.f
1699   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1700   int UNUSED written = 0;
1701   IADDR UNUSED pc = abuf->addr;
1702   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1703
1704   {
1705     SI opval = TRUNCDISI (SRADI (GET_H_ACCUM (), 32));
1706     * FLD (i_dr) = opval;
1707     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1708   }
1709
1710   return vpc;
1711 #undef FLD
1712 }
1713
1714 /* mvfaclo: mvfaclo $dr */
1715
1716 static SEM_PC
1717 SEM_FN_NAME (m32rbf,mvfaclo) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1718 {
1719 #define FLD(f) abuf->fields.sfmt_seth.f
1720   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1721   int UNUSED written = 0;
1722   IADDR UNUSED pc = abuf->addr;
1723   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1724
1725   {
1726     SI opval = TRUNCDISI (GET_H_ACCUM ());
1727     * FLD (i_dr) = opval;
1728     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1729   }
1730
1731   return vpc;
1732 #undef FLD
1733 }
1734
1735 /* mvfacmi: mvfacmi $dr */
1736
1737 static SEM_PC
1738 SEM_FN_NAME (m32rbf,mvfacmi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1739 {
1740 #define FLD(f) abuf->fields.sfmt_seth.f
1741   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1742   int UNUSED written = 0;
1743   IADDR UNUSED pc = abuf->addr;
1744   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1745
1746   {
1747     SI opval = TRUNCDISI (SRADI (GET_H_ACCUM (), 16));
1748     * FLD (i_dr) = opval;
1749     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1750   }
1751
1752   return vpc;
1753 #undef FLD
1754 }
1755
1756 /* mvfc: mvfc $dr,$scr */
1757
1758 static SEM_PC
1759 SEM_FN_NAME (m32rbf,mvfc) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1760 {
1761 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1762   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1763   int UNUSED written = 0;
1764   IADDR UNUSED pc = abuf->addr;
1765   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1766
1767   {
1768     SI opval = GET_H_CR (FLD (f_r2));
1769     * FLD (i_dr) = opval;
1770     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1771   }
1772
1773   return vpc;
1774 #undef FLD
1775 }
1776
1777 /* mvtachi: mvtachi $src1 */
1778
1779 static SEM_PC
1780 SEM_FN_NAME (m32rbf,mvtachi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1781 {
1782 #define FLD(f) abuf->fields.sfmt_st_plus.f
1783   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1784   int UNUSED written = 0;
1785   IADDR UNUSED pc = abuf->addr;
1786   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1787
1788   {
1789     DI opval = ORDI (ANDDI (GET_H_ACCUM (), MAKEDI (0, 0xffffffff)), SLLDI (EXTSIDI (* FLD (i_src1)), 32));
1790     SET_H_ACCUM (opval);
1791     TRACE_RESULT (current_cpu, abuf, "accum", 'D', opval);
1792   }
1793
1794   return vpc;
1795 #undef FLD
1796 }
1797
1798 /* mvtaclo: mvtaclo $src1 */
1799
1800 static SEM_PC
1801 SEM_FN_NAME (m32rbf,mvtaclo) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1802 {
1803 #define FLD(f) abuf->fields.sfmt_st_plus.f
1804   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1805   int UNUSED written = 0;
1806   IADDR UNUSED pc = abuf->addr;
1807   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1808
1809   {
1810     DI opval = ORDI (ANDDI (GET_H_ACCUM (), MAKEDI (0xffffffff, 0)), ZEXTSIDI (* FLD (i_src1)));
1811     SET_H_ACCUM (opval);
1812     TRACE_RESULT (current_cpu, abuf, "accum", 'D', opval);
1813   }
1814
1815   return vpc;
1816 #undef FLD
1817 }
1818
1819 /* mvtc: mvtc $sr,$dcr */
1820
1821 static SEM_PC
1822 SEM_FN_NAME (m32rbf,mvtc) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1823 {
1824 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1825   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1826   int UNUSED written = 0;
1827   IADDR UNUSED pc = abuf->addr;
1828   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1829
1830   {
1831     USI opval = * FLD (i_sr);
1832     SET_H_CR (FLD (f_r1), opval);
1833     TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
1834   }
1835
1836   return vpc;
1837 #undef FLD
1838 }
1839
1840 /* neg: neg $dr,$sr */
1841
1842 static SEM_PC
1843 SEM_FN_NAME (m32rbf,neg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1844 {
1845 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1846   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1847   int UNUSED written = 0;
1848   IADDR UNUSED pc = abuf->addr;
1849   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1850
1851   {
1852     SI opval = NEGSI (* FLD (i_sr));
1853     * FLD (i_dr) = opval;
1854     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1855   }
1856
1857   return vpc;
1858 #undef FLD
1859 }
1860
1861 /* nop: nop */
1862
1863 static SEM_PC
1864 SEM_FN_NAME (m32rbf,nop) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1865 {
1866 #define FLD(f) abuf->fields.sfmt_empty.f
1867   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1868   int UNUSED written = 0;
1869   IADDR UNUSED pc = abuf->addr;
1870   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1871
1872 PROFILE_COUNT_FILLNOPS (current_cpu, abuf->addr);
1873
1874   return vpc;
1875 #undef FLD
1876 }
1877
1878 /* not: not $dr,$sr */
1879
1880 static SEM_PC
1881 SEM_FN_NAME (m32rbf,not) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1882 {
1883 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1884   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1885   int UNUSED written = 0;
1886   IADDR UNUSED pc = abuf->addr;
1887   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1888
1889   {
1890     SI opval = INVSI (* FLD (i_sr));
1891     * FLD (i_dr) = opval;
1892     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1893   }
1894
1895   return vpc;
1896 #undef FLD
1897 }
1898
1899 /* rac: rac */
1900
1901 static SEM_PC
1902 SEM_FN_NAME (m32rbf,rac) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1903 {
1904 #define FLD(f) abuf->fields.sfmt_empty.f
1905   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1906   int UNUSED written = 0;
1907   IADDR UNUSED pc = abuf->addr;
1908   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1909
1910 {
1911   DI tmp_tmp1;
1912   tmp_tmp1 = SLLDI (GET_H_ACCUM (), 1);
1913   tmp_tmp1 = ADDDI (tmp_tmp1, MAKEDI (0, 32768));
1914   {
1915     DI opval = (GTDI (tmp_tmp1, MAKEDI (32767, 0xffff0000))) ? (MAKEDI (32767, 0xffff0000)) : (LTDI (tmp_tmp1, MAKEDI (0xffff8000, 0))) ? (MAKEDI (0xffff8000, 0)) : (ANDDI (tmp_tmp1, MAKEDI (0xffffffff, 0xffff0000)));
1916     SET_H_ACCUM (opval);
1917     TRACE_RESULT (current_cpu, abuf, "accum", 'D', opval);
1918   }
1919 }
1920
1921   return vpc;
1922 #undef FLD
1923 }
1924
1925 /* rach: rach */
1926
1927 static SEM_PC
1928 SEM_FN_NAME (m32rbf,rach) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1929 {
1930 #define FLD(f) abuf->fields.sfmt_empty.f
1931   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1932   int UNUSED written = 0;
1933   IADDR UNUSED pc = abuf->addr;
1934   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1935
1936 {
1937   DI tmp_tmp1;
1938   tmp_tmp1 = ANDDI (GET_H_ACCUM (), MAKEDI (16777215, 0xffffffff));
1939 if (ANDIF (GEDI (tmp_tmp1, MAKEDI (16383, 0x80000000)), LEDI (tmp_tmp1, MAKEDI (8388607, 0xffffffff)))) {
1940   tmp_tmp1 = MAKEDI (16383, 0x80000000);
1941 } else {
1942 if (ANDIF (GEDI (tmp_tmp1, MAKEDI (8388608, 0)), LEDI (tmp_tmp1, MAKEDI (16760832, 0)))) {
1943   tmp_tmp1 = MAKEDI (16760832, 0);
1944 } else {
1945   tmp_tmp1 = ANDDI (ADDDI (GET_H_ACCUM (), MAKEDI (0, 1073741824)), MAKEDI (0xffffffff, 0x80000000));
1946 }
1947 }
1948   tmp_tmp1 = SLLDI (tmp_tmp1, 1);
1949   {
1950     DI opval = SRADI (SLLDI (tmp_tmp1, 7), 7);
1951     SET_H_ACCUM (opval);
1952     TRACE_RESULT (current_cpu, abuf, "accum", 'D', opval);
1953   }
1954 }
1955
1956   return vpc;
1957 #undef FLD
1958 }
1959
1960 /* rte: rte */
1961
1962 static SEM_PC
1963 SEM_FN_NAME (m32rbf,rte) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1964 {
1965 #define FLD(f) abuf->fields.sfmt_empty.f
1966   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1967   int UNUSED written = 0;
1968   IADDR UNUSED pc = abuf->addr;
1969   SEM_BRANCH_INIT
1970   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1971
1972 {
1973   {
1974     USI opval = ANDSI (GET_H_CR (((UINT) 6)), -4);
1975     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
1976     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1977   }
1978   {
1979     USI opval = GET_H_CR (((UINT) 14));
1980     SET_H_CR (((UINT) 6), opval);
1981     TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
1982   }
1983   {
1984     UQI opval = CPU (h_bpsw);
1985     SET_H_PSW (opval);
1986     TRACE_RESULT (current_cpu, abuf, "psw", 'x', opval);
1987   }
1988   {
1989     UQI opval = CPU (h_bbpsw);
1990     CPU (h_bpsw) = opval;
1991     TRACE_RESULT (current_cpu, abuf, "bpsw", 'x', opval);
1992   }
1993 }
1994
1995   SEM_BRANCH_FINI (vpc);
1996   return vpc;
1997 #undef FLD
1998 }
1999
2000 /* seth: seth $dr,$hash$hi16 */
2001
2002 static SEM_PC
2003 SEM_FN_NAME (m32rbf,seth) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2004 {
2005 #define FLD(f) abuf->fields.sfmt_seth.f
2006   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2007   int UNUSED written = 0;
2008   IADDR UNUSED pc = abuf->addr;
2009   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2010
2011   {
2012     SI opval = SLLSI (FLD (f_hi16), 16);
2013     * FLD (i_dr) = opval;
2014     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2015   }
2016
2017   return vpc;
2018 #undef FLD
2019 }
2020
2021 /* sll: sll $dr,$sr */
2022
2023 static SEM_PC
2024 SEM_FN_NAME (m32rbf,sll) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2025 {
2026 #define FLD(f) abuf->fields.sfmt_add.f
2027   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2028   int UNUSED written = 0;
2029   IADDR UNUSED pc = abuf->addr;
2030   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2031
2032   {
2033     SI opval = SLLSI (* FLD (i_dr), ANDSI (* FLD (i_sr), 31));
2034     * FLD (i_dr) = opval;
2035     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2036   }
2037
2038   return vpc;
2039 #undef FLD
2040 }
2041
2042 /* sll3: sll3 $dr,$sr,$simm16 */
2043
2044 static SEM_PC
2045 SEM_FN_NAME (m32rbf,sll3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2046 {
2047 #define FLD(f) abuf->fields.sfmt_add3.f
2048   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2049   int UNUSED written = 0;
2050   IADDR UNUSED pc = abuf->addr;
2051   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2052
2053   {
2054     SI opval = SLLSI (* FLD (i_sr), ANDSI (FLD (f_simm16), 31));
2055     * FLD (i_dr) = opval;
2056     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2057   }
2058
2059   return vpc;
2060 #undef FLD
2061 }
2062
2063 /* slli: slli $dr,$uimm5 */
2064
2065 static SEM_PC
2066 SEM_FN_NAME (m32rbf,slli) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2067 {
2068 #define FLD(f) abuf->fields.sfmt_slli.f
2069   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2070   int UNUSED written = 0;
2071   IADDR UNUSED pc = abuf->addr;
2072   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2073
2074   {
2075     SI opval = SLLSI (* FLD (i_dr), FLD (f_uimm5));
2076     * FLD (i_dr) = opval;
2077     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2078   }
2079
2080   return vpc;
2081 #undef FLD
2082 }
2083
2084 /* sra: sra $dr,$sr */
2085
2086 static SEM_PC
2087 SEM_FN_NAME (m32rbf,sra) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2088 {
2089 #define FLD(f) abuf->fields.sfmt_add.f
2090   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2091   int UNUSED written = 0;
2092   IADDR UNUSED pc = abuf->addr;
2093   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2094
2095   {
2096     SI opval = SRASI (* FLD (i_dr), ANDSI (* FLD (i_sr), 31));
2097     * FLD (i_dr) = opval;
2098     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2099   }
2100
2101   return vpc;
2102 #undef FLD
2103 }
2104
2105 /* sra3: sra3 $dr,$sr,$simm16 */
2106
2107 static SEM_PC
2108 SEM_FN_NAME (m32rbf,sra3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2109 {
2110 #define FLD(f) abuf->fields.sfmt_add3.f
2111   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2112   int UNUSED written = 0;
2113   IADDR UNUSED pc = abuf->addr;
2114   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2115
2116   {
2117     SI opval = SRASI (* FLD (i_sr), ANDSI (FLD (f_simm16), 31));
2118     * FLD (i_dr) = opval;
2119     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2120   }
2121
2122   return vpc;
2123 #undef FLD
2124 }
2125
2126 /* srai: srai $dr,$uimm5 */
2127
2128 static SEM_PC
2129 SEM_FN_NAME (m32rbf,srai) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2130 {
2131 #define FLD(f) abuf->fields.sfmt_slli.f
2132   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2133   int UNUSED written = 0;
2134   IADDR UNUSED pc = abuf->addr;
2135   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2136
2137   {
2138     SI opval = SRASI (* FLD (i_dr), FLD (f_uimm5));
2139     * FLD (i_dr) = opval;
2140     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2141   }
2142
2143   return vpc;
2144 #undef FLD
2145 }
2146
2147 /* srl: srl $dr,$sr */
2148
2149 static SEM_PC
2150 SEM_FN_NAME (m32rbf,srl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2151 {
2152 #define FLD(f) abuf->fields.sfmt_add.f
2153   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2154   int UNUSED written = 0;
2155   IADDR UNUSED pc = abuf->addr;
2156   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2157
2158   {
2159     SI opval = SRLSI (* FLD (i_dr), ANDSI (* FLD (i_sr), 31));
2160     * FLD (i_dr) = opval;
2161     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2162   }
2163
2164   return vpc;
2165 #undef FLD
2166 }
2167
2168 /* srl3: srl3 $dr,$sr,$simm16 */
2169
2170 static SEM_PC
2171 SEM_FN_NAME (m32rbf,srl3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2172 {
2173 #define FLD(f) abuf->fields.sfmt_add3.f
2174   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2175   int UNUSED written = 0;
2176   IADDR UNUSED pc = abuf->addr;
2177   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2178
2179   {
2180     SI opval = SRLSI (* FLD (i_sr), ANDSI (FLD (f_simm16), 31));
2181     * FLD (i_dr) = opval;
2182     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2183   }
2184
2185   return vpc;
2186 #undef FLD
2187 }
2188
2189 /* srli: srli $dr,$uimm5 */
2190
2191 static SEM_PC
2192 SEM_FN_NAME (m32rbf,srli) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2193 {
2194 #define FLD(f) abuf->fields.sfmt_slli.f
2195   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2196   int UNUSED written = 0;
2197   IADDR UNUSED pc = abuf->addr;
2198   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2199
2200   {
2201     SI opval = SRLSI (* FLD (i_dr), FLD (f_uimm5));
2202     * FLD (i_dr) = opval;
2203     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2204   }
2205
2206   return vpc;
2207 #undef FLD
2208 }
2209
2210 /* st: st $src1,@$src2 */
2211
2212 static SEM_PC
2213 SEM_FN_NAME (m32rbf,st) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2214 {
2215 #define FLD(f) abuf->fields.sfmt_st_plus.f
2216   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2217   int UNUSED written = 0;
2218   IADDR UNUSED pc = abuf->addr;
2219   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2220
2221   {
2222     SI opval = * FLD (i_src1);
2223     SETMEMSI (current_cpu, pc, * FLD (i_src2), opval);
2224     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2225   }
2226
2227   return vpc;
2228 #undef FLD
2229 }
2230
2231 /* st-d: st $src1,@($slo16,$src2) */
2232
2233 static SEM_PC
2234 SEM_FN_NAME (m32rbf,st_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2235 {
2236 #define FLD(f) abuf->fields.sfmt_st_d.f
2237   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2238   int UNUSED written = 0;
2239   IADDR UNUSED pc = abuf->addr;
2240   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2241
2242   {
2243     SI opval = * FLD (i_src1);
2244     SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_src2), FLD (f_simm16)), opval);
2245     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2246   }
2247
2248   return vpc;
2249 #undef FLD
2250 }
2251
2252 /* stb: stb $src1,@$src2 */
2253
2254 static SEM_PC
2255 SEM_FN_NAME (m32rbf,stb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2256 {
2257 #define FLD(f) abuf->fields.sfmt_st_plus.f
2258   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2259   int UNUSED written = 0;
2260   IADDR UNUSED pc = abuf->addr;
2261   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2262
2263   {
2264     QI opval = * FLD (i_src1);
2265     SETMEMQI (current_cpu, pc, * FLD (i_src2), opval);
2266     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2267   }
2268
2269   return vpc;
2270 #undef FLD
2271 }
2272
2273 /* stb-d: stb $src1,@($slo16,$src2) */
2274
2275 static SEM_PC
2276 SEM_FN_NAME (m32rbf,stb_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2277 {
2278 #define FLD(f) abuf->fields.sfmt_st_d.f
2279   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2280   int UNUSED written = 0;
2281   IADDR UNUSED pc = abuf->addr;
2282   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2283
2284   {
2285     QI opval = * FLD (i_src1);
2286     SETMEMQI (current_cpu, pc, ADDSI (* FLD (i_src2), FLD (f_simm16)), opval);
2287     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2288   }
2289
2290   return vpc;
2291 #undef FLD
2292 }
2293
2294 /* sth: sth $src1,@$src2 */
2295
2296 static SEM_PC
2297 SEM_FN_NAME (m32rbf,sth) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2298 {
2299 #define FLD(f) abuf->fields.sfmt_st_plus.f
2300   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2301   int UNUSED written = 0;
2302   IADDR UNUSED pc = abuf->addr;
2303   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2304
2305   {
2306     HI opval = * FLD (i_src1);
2307     SETMEMHI (current_cpu, pc, * FLD (i_src2), opval);
2308     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2309   }
2310
2311   return vpc;
2312 #undef FLD
2313 }
2314
2315 /* sth-d: sth $src1,@($slo16,$src2) */
2316
2317 static SEM_PC
2318 SEM_FN_NAME (m32rbf,sth_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2319 {
2320 #define FLD(f) abuf->fields.sfmt_st_d.f
2321   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2322   int UNUSED written = 0;
2323   IADDR UNUSED pc = abuf->addr;
2324   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2325
2326   {
2327     HI opval = * FLD (i_src1);
2328     SETMEMHI (current_cpu, pc, ADDSI (* FLD (i_src2), FLD (f_simm16)), opval);
2329     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2330   }
2331
2332   return vpc;
2333 #undef FLD
2334 }
2335
2336 /* st-plus: st $src1,@+$src2 */
2337
2338 static SEM_PC
2339 SEM_FN_NAME (m32rbf,st_plus) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2340 {
2341 #define FLD(f) abuf->fields.sfmt_st_plus.f
2342   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2343   int UNUSED written = 0;
2344   IADDR UNUSED pc = abuf->addr;
2345   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2346
2347 {
2348   SI tmp_new_src2;
2349   tmp_new_src2 = ADDSI (* FLD (i_src2), 4);
2350   {
2351     SI opval = * FLD (i_src1);
2352     SETMEMSI (current_cpu, pc, tmp_new_src2, opval);
2353     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2354   }
2355   {
2356     SI opval = tmp_new_src2;
2357     * FLD (i_src2) = opval;
2358     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2359   }
2360 }
2361
2362   return vpc;
2363 #undef FLD
2364 }
2365
2366 /* st-minus: st $src1,@-$src2 */
2367
2368 static SEM_PC
2369 SEM_FN_NAME (m32rbf,st_minus) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2370 {
2371 #define FLD(f) abuf->fields.sfmt_st_plus.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   SI tmp_new_src2;
2379   tmp_new_src2 = SUBSI (* FLD (i_src2), 4);
2380   {
2381     SI opval = * FLD (i_src1);
2382     SETMEMSI (current_cpu, pc, tmp_new_src2, opval);
2383     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2384   }
2385   {
2386     SI opval = tmp_new_src2;
2387     * FLD (i_src2) = opval;
2388     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2389   }
2390 }
2391
2392   return vpc;
2393 #undef FLD
2394 }
2395
2396 /* sub: sub $dr,$sr */
2397
2398 static SEM_PC
2399 SEM_FN_NAME (m32rbf,sub) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2400 {
2401 #define FLD(f) abuf->fields.sfmt_add.f
2402   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2403   int UNUSED written = 0;
2404   IADDR UNUSED pc = abuf->addr;
2405   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2406
2407   {
2408     SI opval = SUBSI (* FLD (i_dr), * FLD (i_sr));
2409     * FLD (i_dr) = opval;
2410     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2411   }
2412
2413   return vpc;
2414 #undef FLD
2415 }
2416
2417 /* subv: subv $dr,$sr */
2418
2419 static SEM_PC
2420 SEM_FN_NAME (m32rbf,subv) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2421 {
2422 #define FLD(f) abuf->fields.sfmt_add.f
2423   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2424   int UNUSED written = 0;
2425   IADDR UNUSED pc = abuf->addr;
2426   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2427
2428 {
2429   SI temp0;BI temp1;
2430   temp0 = SUBSI (* FLD (i_dr), * FLD (i_sr));
2431   temp1 = SUBOFSI (* FLD (i_dr), * FLD (i_sr), 0);
2432   {
2433     SI opval = temp0;
2434     * FLD (i_dr) = opval;
2435     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2436   }
2437   {
2438     BI opval = temp1;
2439     CPU (h_cond) = opval;
2440     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
2441   }
2442 }
2443
2444   return vpc;
2445 #undef FLD
2446 }
2447
2448 /* subx: subx $dr,$sr */
2449
2450 static SEM_PC
2451 SEM_FN_NAME (m32rbf,subx) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2452 {
2453 #define FLD(f) abuf->fields.sfmt_add.f
2454   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2455   int UNUSED written = 0;
2456   IADDR UNUSED pc = abuf->addr;
2457   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2458
2459 {
2460   SI temp0;BI temp1;
2461   temp0 = SUBCSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
2462   temp1 = SUBCFSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
2463   {
2464     SI opval = temp0;
2465     * FLD (i_dr) = opval;
2466     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2467   }
2468   {
2469     BI opval = temp1;
2470     CPU (h_cond) = opval;
2471     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
2472   }
2473 }
2474
2475   return vpc;
2476 #undef FLD
2477 }
2478
2479 /* trap: trap $uimm4 */
2480
2481 static SEM_PC
2482 SEM_FN_NAME (m32rbf,trap) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2483 {
2484 #define FLD(f) abuf->fields.sfmt_trap.f
2485   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2486   int UNUSED written = 0;
2487   IADDR UNUSED pc = abuf->addr;
2488   SEM_BRANCH_INIT
2489   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2490
2491 {
2492   {
2493     USI opval = GET_H_CR (((UINT) 6));
2494     SET_H_CR (((UINT) 14), opval);
2495     TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
2496   }
2497   {
2498     USI opval = ADDSI (pc, 4);
2499     SET_H_CR (((UINT) 6), opval);
2500     TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
2501   }
2502   {
2503     UQI opval = CPU (h_bpsw);
2504     CPU (h_bbpsw) = opval;
2505     TRACE_RESULT (current_cpu, abuf, "bbpsw", 'x', opval);
2506   }
2507   {
2508     UQI opval = GET_H_PSW ();
2509     CPU (h_bpsw) = opval;
2510     TRACE_RESULT (current_cpu, abuf, "bpsw", 'x', opval);
2511   }
2512   {
2513     UQI opval = ANDQI (GET_H_PSW (), 128);
2514     SET_H_PSW (opval);
2515     TRACE_RESULT (current_cpu, abuf, "psw", 'x', opval);
2516   }
2517   {
2518     SI opval = m32r_trap (current_cpu, pc, FLD (f_uimm4));
2519     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
2520     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
2521   }
2522 }
2523
2524   SEM_BRANCH_FINI (vpc);
2525   return vpc;
2526 #undef FLD
2527 }
2528
2529 /* unlock: unlock $src1,@$src2 */
2530
2531 static SEM_PC
2532 SEM_FN_NAME (m32rbf,unlock) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2533 {
2534 #define FLD(f) abuf->fields.sfmt_st_plus.f
2535   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2536   int UNUSED written = 0;
2537   IADDR UNUSED pc = abuf->addr;
2538   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2539
2540 {
2541 if (CPU (h_lock)) {
2542   {
2543     SI opval = * FLD (i_src1);
2544     SETMEMSI (current_cpu, pc, * FLD (i_src2), opval);
2545     written |= (1 << 4);
2546     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2547   }
2548 }
2549   {
2550     BI opval = 0;
2551     CPU (h_lock) = opval;
2552     TRACE_RESULT (current_cpu, abuf, "lock", 'x', opval);
2553   }
2554 }
2555
2556   abuf->written = written;
2557   return vpc;
2558 #undef FLD
2559 }
2560
2561 /* clrpsw: clrpsw $uimm8 */
2562
2563 static SEM_PC
2564 SEM_FN_NAME (m32rbf,clrpsw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2565 {
2566 #define FLD(f) abuf->fields.sfmt_clrpsw.f
2567   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2568   int UNUSED written = 0;
2569   IADDR UNUSED pc = abuf->addr;
2570   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2571
2572   {
2573     USI opval = ANDSI (GET_H_CR (((UINT) 0)), ORSI (ZEXTQISI (INVQI (FLD (f_uimm8))), 65280));
2574     SET_H_CR (((UINT) 0), opval);
2575     TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
2576   }
2577
2578   return vpc;
2579 #undef FLD
2580 }
2581
2582 /* setpsw: setpsw $uimm8 */
2583
2584 static SEM_PC
2585 SEM_FN_NAME (m32rbf,setpsw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2586 {
2587 #define FLD(f) abuf->fields.sfmt_clrpsw.f
2588   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2589   int UNUSED written = 0;
2590   IADDR UNUSED pc = abuf->addr;
2591   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2592
2593   {
2594     USI opval = FLD (f_uimm8);
2595     SET_H_CR (((UINT) 0), opval);
2596     TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
2597   }
2598
2599   return vpc;
2600 #undef FLD
2601 }
2602
2603 /* bset: bset $uimm3,@($slo16,$sr) */
2604
2605 static SEM_PC
2606 SEM_FN_NAME (m32rbf,bset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2607 {
2608 #define FLD(f) abuf->fields.sfmt_bset.f
2609   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2610   int UNUSED written = 0;
2611   IADDR UNUSED pc = abuf->addr;
2612   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2613
2614   {
2615     QI opval = ORQI (GETMEMQI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16))), SLLQI (1, SUBSI (7, FLD (f_uimm3))));
2616     SETMEMQI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16)), opval);
2617     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2618   }
2619
2620   return vpc;
2621 #undef FLD
2622 }
2623
2624 /* bclr: bclr $uimm3,@($slo16,$sr) */
2625
2626 static SEM_PC
2627 SEM_FN_NAME (m32rbf,bclr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2628 {
2629 #define FLD(f) abuf->fields.sfmt_bset.f
2630   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2631   int UNUSED written = 0;
2632   IADDR UNUSED pc = abuf->addr;
2633   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2634
2635   {
2636     QI opval = ANDQI (GETMEMQI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16))), INVQI (SLLQI (1, SUBSI (7, FLD (f_uimm3)))));
2637     SETMEMQI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16)), opval);
2638     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2639   }
2640
2641   return vpc;
2642 #undef FLD
2643 }
2644
2645 /* btst: btst $uimm3,$sr */
2646
2647 static SEM_PC
2648 SEM_FN_NAME (m32rbf,btst) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2649 {
2650 #define FLD(f) abuf->fields.sfmt_bset.f
2651   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2652   int UNUSED written = 0;
2653   IADDR UNUSED pc = abuf->addr;
2654   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2655
2656   {
2657     BI opval = ANDQI (SRLQI (* FLD (i_sr), SUBSI (7, FLD (f_uimm3))), 1);
2658     CPU (h_cond) = opval;
2659     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
2660   }
2661
2662   return vpc;
2663 #undef FLD
2664 }
2665
2666 /* Table of all semantic fns.  */
2667
2668 static const struct sem_fn_desc sem_fns[] = {
2669   { M32RBF_INSN_X_INVALID, SEM_FN_NAME (m32rbf,x_invalid) },
2670   { M32RBF_INSN_X_AFTER, SEM_FN_NAME (m32rbf,x_after) },
2671   { M32RBF_INSN_X_BEFORE, SEM_FN_NAME (m32rbf,x_before) },
2672   { M32RBF_INSN_X_CTI_CHAIN, SEM_FN_NAME (m32rbf,x_cti_chain) },
2673   { M32RBF_INSN_X_CHAIN, SEM_FN_NAME (m32rbf,x_chain) },
2674   { M32RBF_INSN_X_BEGIN, SEM_FN_NAME (m32rbf,x_begin) },
2675   { M32RBF_INSN_ADD, SEM_FN_NAME (m32rbf,add) },
2676   { M32RBF_INSN_ADD3, SEM_FN_NAME (m32rbf,add3) },
2677   { M32RBF_INSN_AND, SEM_FN_NAME (m32rbf,and) },
2678   { M32RBF_INSN_AND3, SEM_FN_NAME (m32rbf,and3) },
2679   { M32RBF_INSN_OR, SEM_FN_NAME (m32rbf,or) },
2680   { M32RBF_INSN_OR3, SEM_FN_NAME (m32rbf,or3) },
2681   { M32RBF_INSN_XOR, SEM_FN_NAME (m32rbf,xor) },
2682   { M32RBF_INSN_XOR3, SEM_FN_NAME (m32rbf,xor3) },
2683   { M32RBF_INSN_ADDI, SEM_FN_NAME (m32rbf,addi) },
2684   { M32RBF_INSN_ADDV, SEM_FN_NAME (m32rbf,addv) },
2685   { M32RBF_INSN_ADDV3, SEM_FN_NAME (m32rbf,addv3) },
2686   { M32RBF_INSN_ADDX, SEM_FN_NAME (m32rbf,addx) },
2687   { M32RBF_INSN_BC8, SEM_FN_NAME (m32rbf,bc8) },
2688   { M32RBF_INSN_BC24, SEM_FN_NAME (m32rbf,bc24) },
2689   { M32RBF_INSN_BEQ, SEM_FN_NAME (m32rbf,beq) },
2690   { M32RBF_INSN_BEQZ, SEM_FN_NAME (m32rbf,beqz) },
2691   { M32RBF_INSN_BGEZ, SEM_FN_NAME (m32rbf,bgez) },
2692   { M32RBF_INSN_BGTZ, SEM_FN_NAME (m32rbf,bgtz) },
2693   { M32RBF_INSN_BLEZ, SEM_FN_NAME (m32rbf,blez) },
2694   { M32RBF_INSN_BLTZ, SEM_FN_NAME (m32rbf,bltz) },
2695   { M32RBF_INSN_BNEZ, SEM_FN_NAME (m32rbf,bnez) },
2696   { M32RBF_INSN_BL8, SEM_FN_NAME (m32rbf,bl8) },
2697   { M32RBF_INSN_BL24, SEM_FN_NAME (m32rbf,bl24) },
2698   { M32RBF_INSN_BNC8, SEM_FN_NAME (m32rbf,bnc8) },
2699   { M32RBF_INSN_BNC24, SEM_FN_NAME (m32rbf,bnc24) },
2700   { M32RBF_INSN_BNE, SEM_FN_NAME (m32rbf,bne) },
2701   { M32RBF_INSN_BRA8, SEM_FN_NAME (m32rbf,bra8) },
2702   { M32RBF_INSN_BRA24, SEM_FN_NAME (m32rbf,bra24) },
2703   { M32RBF_INSN_CMP, SEM_FN_NAME (m32rbf,cmp) },
2704   { M32RBF_INSN_CMPI, SEM_FN_NAME (m32rbf,cmpi) },
2705   { M32RBF_INSN_CMPU, SEM_FN_NAME (m32rbf,cmpu) },
2706   { M32RBF_INSN_CMPUI, SEM_FN_NAME (m32rbf,cmpui) },
2707   { M32RBF_INSN_DIV, SEM_FN_NAME (m32rbf,div) },
2708   { M32RBF_INSN_DIVU, SEM_FN_NAME (m32rbf,divu) },
2709   { M32RBF_INSN_REM, SEM_FN_NAME (m32rbf,rem) },
2710   { M32RBF_INSN_REMU, SEM_FN_NAME (m32rbf,remu) },
2711   { M32RBF_INSN_JL, SEM_FN_NAME (m32rbf,jl) },
2712   { M32RBF_INSN_JMP, SEM_FN_NAME (m32rbf,jmp) },
2713   { M32RBF_INSN_LD, SEM_FN_NAME (m32rbf,ld) },
2714   { M32RBF_INSN_LD_D, SEM_FN_NAME (m32rbf,ld_d) },
2715   { M32RBF_INSN_LDB, SEM_FN_NAME (m32rbf,ldb) },
2716   { M32RBF_INSN_LDB_D, SEM_FN_NAME (m32rbf,ldb_d) },
2717   { M32RBF_INSN_LDH, SEM_FN_NAME (m32rbf,ldh) },
2718   { M32RBF_INSN_LDH_D, SEM_FN_NAME (m32rbf,ldh_d) },
2719   { M32RBF_INSN_LDUB, SEM_FN_NAME (m32rbf,ldub) },
2720   { M32RBF_INSN_LDUB_D, SEM_FN_NAME (m32rbf,ldub_d) },
2721   { M32RBF_INSN_LDUH, SEM_FN_NAME (m32rbf,lduh) },
2722   { M32RBF_INSN_LDUH_D, SEM_FN_NAME (m32rbf,lduh_d) },
2723   { M32RBF_INSN_LD_PLUS, SEM_FN_NAME (m32rbf,ld_plus) },
2724   { M32RBF_INSN_LD24, SEM_FN_NAME (m32rbf,ld24) },
2725   { M32RBF_INSN_LDI8, SEM_FN_NAME (m32rbf,ldi8) },
2726   { M32RBF_INSN_LDI16, SEM_FN_NAME (m32rbf,ldi16) },
2727   { M32RBF_INSN_LOCK, SEM_FN_NAME (m32rbf,lock) },
2728   { M32RBF_INSN_MACHI, SEM_FN_NAME (m32rbf,machi) },
2729   { M32RBF_INSN_MACLO, SEM_FN_NAME (m32rbf,maclo) },
2730   { M32RBF_INSN_MACWHI, SEM_FN_NAME (m32rbf,macwhi) },
2731   { M32RBF_INSN_MACWLO, SEM_FN_NAME (m32rbf,macwlo) },
2732   { M32RBF_INSN_MUL, SEM_FN_NAME (m32rbf,mul) },
2733   { M32RBF_INSN_MULHI, SEM_FN_NAME (m32rbf,mulhi) },
2734   { M32RBF_INSN_MULLO, SEM_FN_NAME (m32rbf,mullo) },
2735   { M32RBF_INSN_MULWHI, SEM_FN_NAME (m32rbf,mulwhi) },
2736   { M32RBF_INSN_MULWLO, SEM_FN_NAME (m32rbf,mulwlo) },
2737   { M32RBF_INSN_MV, SEM_FN_NAME (m32rbf,mv) },
2738   { M32RBF_INSN_MVFACHI, SEM_FN_NAME (m32rbf,mvfachi) },
2739   { M32RBF_INSN_MVFACLO, SEM_FN_NAME (m32rbf,mvfaclo) },
2740   { M32RBF_INSN_MVFACMI, SEM_FN_NAME (m32rbf,mvfacmi) },
2741   { M32RBF_INSN_MVFC, SEM_FN_NAME (m32rbf,mvfc) },
2742   { M32RBF_INSN_MVTACHI, SEM_FN_NAME (m32rbf,mvtachi) },
2743   { M32RBF_INSN_MVTACLO, SEM_FN_NAME (m32rbf,mvtaclo) },
2744   { M32RBF_INSN_MVTC, SEM_FN_NAME (m32rbf,mvtc) },
2745   { M32RBF_INSN_NEG, SEM_FN_NAME (m32rbf,neg) },
2746   { M32RBF_INSN_NOP, SEM_FN_NAME (m32rbf,nop) },
2747   { M32RBF_INSN_NOT, SEM_FN_NAME (m32rbf,not) },
2748   { M32RBF_INSN_RAC, SEM_FN_NAME (m32rbf,rac) },
2749   { M32RBF_INSN_RACH, SEM_FN_NAME (m32rbf,rach) },
2750   { M32RBF_INSN_RTE, SEM_FN_NAME (m32rbf,rte) },
2751   { M32RBF_INSN_SETH, SEM_FN_NAME (m32rbf,seth) },
2752   { M32RBF_INSN_SLL, SEM_FN_NAME (m32rbf,sll) },
2753   { M32RBF_INSN_SLL3, SEM_FN_NAME (m32rbf,sll3) },
2754   { M32RBF_INSN_SLLI, SEM_FN_NAME (m32rbf,slli) },
2755   { M32RBF_INSN_SRA, SEM_FN_NAME (m32rbf,sra) },
2756   { M32RBF_INSN_SRA3, SEM_FN_NAME (m32rbf,sra3) },
2757   { M32RBF_INSN_SRAI, SEM_FN_NAME (m32rbf,srai) },
2758   { M32RBF_INSN_SRL, SEM_FN_NAME (m32rbf,srl) },
2759   { M32RBF_INSN_SRL3, SEM_FN_NAME (m32rbf,srl3) },
2760   { M32RBF_INSN_SRLI, SEM_FN_NAME (m32rbf,srli) },
2761   { M32RBF_INSN_ST, SEM_FN_NAME (m32rbf,st) },
2762   { M32RBF_INSN_ST_D, SEM_FN_NAME (m32rbf,st_d) },
2763   { M32RBF_INSN_STB, SEM_FN_NAME (m32rbf,stb) },
2764   { M32RBF_INSN_STB_D, SEM_FN_NAME (m32rbf,stb_d) },
2765   { M32RBF_INSN_STH, SEM_FN_NAME (m32rbf,sth) },
2766   { M32RBF_INSN_STH_D, SEM_FN_NAME (m32rbf,sth_d) },
2767   { M32RBF_INSN_ST_PLUS, SEM_FN_NAME (m32rbf,st_plus) },
2768   { M32RBF_INSN_ST_MINUS, SEM_FN_NAME (m32rbf,st_minus) },
2769   { M32RBF_INSN_SUB, SEM_FN_NAME (m32rbf,sub) },
2770   { M32RBF_INSN_SUBV, SEM_FN_NAME (m32rbf,subv) },
2771   { M32RBF_INSN_SUBX, SEM_FN_NAME (m32rbf,subx) },
2772   { M32RBF_INSN_TRAP, SEM_FN_NAME (m32rbf,trap) },
2773   { M32RBF_INSN_UNLOCK, SEM_FN_NAME (m32rbf,unlock) },
2774   { M32RBF_INSN_CLRPSW, SEM_FN_NAME (m32rbf,clrpsw) },
2775   { M32RBF_INSN_SETPSW, SEM_FN_NAME (m32rbf,setpsw) },
2776   { M32RBF_INSN_BSET, SEM_FN_NAME (m32rbf,bset) },
2777   { M32RBF_INSN_BCLR, SEM_FN_NAME (m32rbf,bclr) },
2778   { M32RBF_INSN_BTST, SEM_FN_NAME (m32rbf,btst) },
2779   { 0, 0 }
2780 };
2781
2782 /* Add the semantic fns to IDESC_TABLE.  */
2783
2784 void
2785 SEM_FN_NAME (m32rbf,init_idesc_table) (SIM_CPU *current_cpu)
2786 {
2787   IDESC *idesc_table = CPU_IDESC (current_cpu);
2788   const struct sem_fn_desc *sf;
2789   int mach_num = MACH_NUM (CPU_MACH (current_cpu));
2790
2791   for (sf = &sem_fns[0]; sf->fn != 0; ++sf)
2792     {
2793       const CGEN_INSN *insn = idesc_table[sf->index].idata;
2794       int valid_p = (CGEN_INSN_VIRTUAL_P (insn)
2795                      || CGEN_INSN_MACH_HAS_P (insn, mach_num));
2796 #if FAST_P
2797       if (valid_p)
2798         idesc_table[sf->index].sem_fast = sf->fn;
2799       else
2800         idesc_table[sf->index].sem_fast = SEM_FN_NAME (m32rbf,x_invalid);
2801 #else
2802       if (valid_p)
2803         idesc_table[sf->index].sem_full = sf->fn;
2804       else
2805         idesc_table[sf->index].sem_full = SEM_FN_NAME (m32rbf,x_invalid);
2806 #endif
2807     }
2808 }
2809