sim/fr30/sem.c

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