sid/component/cgen-cpu/m32r/m32r-sem.cxx

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