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