sim/m32r/sem.c

   1 /* Simulator instruction semantics for m32rb.
   2
   3 THIS FILE IS MACHINE GENERATED WITH CGEN.
   4
   5 Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
   6
   7 This file is part of the GNU Simulators.
   8
   9 This program is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License along
  20 with this program; if not, write to the Free Software Foundation, Inc.,
  21 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  22
  23 */
  24
  25 #define WANT_CPU
  26 #define WANT_CPU_M32RB
  27
  28 #include "sim-main.h"
  29 #include "cgen-mem.h"
  30 #include "cgen-ops.h"
  31 #include "cpu-sim.h"
  32
  33 #if WITH_SCACHE
  34
  35 #undef GET_ATTR
  36 #define GET_ATTR(cpu, num, attr) CGEN_INSN_ATTR (abuf->idesc->opcode, CGEN_INSN_##attr)
  37
  38 /* add: add $dr,$sr.  */
  39
  40 CIA
  41 SEM_FN_NAME (m32rb,add) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
  42 {
  43 #define FLD(f) abuf->fields.fmt_add.f
  44   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
  45   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
  46
  47   {
  48     SI opval = ADDSI (* FLD (f_r1), * FLD (f_r2));
  49     * FLD (f_r1) = opval;
  50     TRACE_RESULT (current_cpu, "dr", 'x', opval);
  51   }
  52
  53   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
  54
  55 #if WITH_PROFILE_MODEL_P
  56   if (PROFILE_MODEL_P (current_cpu))
  57     {
  58       m32rb_model_mark_get_h_gr (current_cpu, abuf);
  59       m32rb_model_mark_set_h_gr (current_cpu, abuf);
  60       m32rb_model_profile_insn (current_cpu, abuf);
  61     }
  62 #endif
  63
  64   return new_pc;
  65 #undef FLD
  66 }
  67
  68 /* add3: add3 $dr,$sr,$hash$slo16.  */
  69
  70 CIA
  71 SEM_FN_NAME (m32rb,add3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
  72 {
  73 #define FLD(f) abuf->fields.fmt_add3.f
  74   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
  75   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
  76
  77   {
  78     SI opval = ADDSI (* FLD (f_r2), FLD (f_simm16));
  79     * FLD (f_r1) = opval;
  80     TRACE_RESULT (current_cpu, "dr", 'x', opval);
  81   }
  82
  83   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
  84
  85 #if WITH_PROFILE_MODEL_P
  86   if (PROFILE_MODEL_P (current_cpu))
  87     {
  88       m32rb_model_mark_get_h_gr (current_cpu, abuf);
  89       m32rb_model_mark_set_h_gr (current_cpu, abuf);
  90       m32rb_model_profile_insn (current_cpu, abuf);
  91     }
  92 #endif
  93
  94   return new_pc;
  95 #undef FLD
  96 }
  97
  98 /* and: and $dr,$sr.  */
  99
 100 CIA
 101 SEM_FN_NAME (m32rb,and) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 102 {
 103 #define FLD(f) abuf->fields.fmt_add.f
 104   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 105   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
 106
 107   {
 108     SI opval = ANDSI (* FLD (f_r1), * FLD (f_r2));
 109     * FLD (f_r1) = opval;
 110     TRACE_RESULT (current_cpu, "dr", 'x', opval);
 111   }
 112
 113   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 114
 115 #if WITH_PROFILE_MODEL_P
 116   if (PROFILE_MODEL_P (current_cpu))
 117     {
 118       m32rb_model_mark_get_h_gr (current_cpu, abuf);
 119       m32rb_model_mark_set_h_gr (current_cpu, abuf);
 120       m32rb_model_profile_insn (current_cpu, abuf);
 121     }
 122 #endif
 123
 124   return new_pc;
 125 #undef FLD
 126 }
 127
 128 /* and3: and3 $dr,$sr,$uimm16.  */
 129
 130 CIA
 131 SEM_FN_NAME (m32rb,and3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 132 {
 133 #define FLD(f) abuf->fields.fmt_and3.f
 134   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 135   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 136
 137   {
 138     SI opval = ANDSI (* FLD (f_r2), FLD (f_uimm16));
 139     * FLD (f_r1) = opval;
 140     TRACE_RESULT (current_cpu, "dr", 'x', opval);
 141   }
 142
 143   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 144
 145 #if WITH_PROFILE_MODEL_P
 146   if (PROFILE_MODEL_P (current_cpu))
 147     {
 148       m32rb_model_mark_get_h_gr (current_cpu, abuf);
 149       m32rb_model_mark_set_h_gr (current_cpu, abuf);
 150       m32rb_model_profile_insn (current_cpu, abuf);
 151     }
 152 #endif
 153
 154   return new_pc;
 155 #undef FLD
 156 }
 157
 158 /* or: or $dr,$sr.  */
 159
 160 CIA
 161 SEM_FN_NAME (m32rb,or) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 162 {
 163 #define FLD(f) abuf->fields.fmt_add.f
 164   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 165   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
 166
 167   {
 168     SI opval = ORSI (* FLD (f_r1), * FLD (f_r2));
 169     * FLD (f_r1) = opval;
 170     TRACE_RESULT (current_cpu, "dr", 'x', opval);
 171   }
 172
 173   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 174
 175 #if WITH_PROFILE_MODEL_P
 176   if (PROFILE_MODEL_P (current_cpu))
 177     {
 178       m32rb_model_mark_get_h_gr (current_cpu, abuf);
 179       m32rb_model_mark_set_h_gr (current_cpu, abuf);
 180       m32rb_model_profile_insn (current_cpu, abuf);
 181     }
 182 #endif
 183
 184   return new_pc;
 185 #undef FLD
 186 }
 187
 188 /* or3: or3 $dr,$sr,$hash$ulo16.  */
 189
 190 CIA
 191 SEM_FN_NAME (m32rb,or3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 192 {
 193 #define FLD(f) abuf->fields.fmt_or3.f
 194   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 195   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 196
 197   {
 198     SI opval = ORSI (* FLD (f_r2), FLD (f_uimm16));
 199     * FLD (f_r1) = opval;
 200     TRACE_RESULT (current_cpu, "dr", 'x', opval);
 201   }
 202
 203   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 204
 205 #if WITH_PROFILE_MODEL_P
 206   if (PROFILE_MODEL_P (current_cpu))
 207     {
 208       m32rb_model_mark_get_h_gr (current_cpu, abuf);
 209       m32rb_model_mark_set_h_gr (current_cpu, abuf);
 210       m32rb_model_profile_insn (current_cpu, abuf);
 211     }
 212 #endif
 213
 214   return new_pc;
 215 #undef FLD
 216 }
 217
 218 /* xor: xor $dr,$sr.  */
 219
 220 CIA
 221 SEM_FN_NAME (m32rb,xor) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 222 {
 223 #define FLD(f) abuf->fields.fmt_add.f
 224   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 225   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
 226
 227   {
 228     SI opval = XORSI (* FLD (f_r1), * FLD (f_r2));
 229     * FLD (f_r1) = opval;
 230     TRACE_RESULT (current_cpu, "dr", 'x', opval);
 231   }
 232
 233   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 234
 235 #if WITH_PROFILE_MODEL_P
 236   if (PROFILE_MODEL_P (current_cpu))
 237     {
 238       m32rb_model_mark_get_h_gr (current_cpu, abuf);
 239       m32rb_model_mark_set_h_gr (current_cpu, abuf);
 240       m32rb_model_profile_insn (current_cpu, abuf);
 241     }
 242 #endif
 243
 244   return new_pc;
 245 #undef FLD
 246 }
 247
 248 /* xor3: xor3 $dr,$sr,$uimm16.  */
 249
 250 CIA
 251 SEM_FN_NAME (m32rb,xor3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 252 {
 253 #define FLD(f) abuf->fields.fmt_and3.f
 254   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 255   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 256
 257   {
 258     SI opval = XORSI (* FLD (f_r2), FLD (f_uimm16));
 259     * FLD (f_r1) = opval;
 260     TRACE_RESULT (current_cpu, "dr", 'x', opval);
 261   }
 262
 263   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 264
 265 #if WITH_PROFILE_MODEL_P
 266   if (PROFILE_MODEL_P (current_cpu))
 267     {
 268       m32rb_model_mark_get_h_gr (current_cpu, abuf);
 269       m32rb_model_mark_set_h_gr (current_cpu, abuf);
 270       m32rb_model_profile_insn (current_cpu, abuf);
 271     }
 272 #endif
 273
 274   return new_pc;
 275 #undef FLD
 276 }
 277
 278 /* addi: addi $dr,$simm8.  */
 279
 280 CIA
 281 SEM_FN_NAME (m32rb,addi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 282 {
 283 #define FLD(f) abuf->fields.fmt_addi.f
 284   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 285   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
 286
 287   {
 288     SI opval = ADDSI (* FLD (f_r1), FLD (f_simm8));
 289     * FLD (f_r1) = opval;
 290     TRACE_RESULT (current_cpu, "dr", 'x', opval);
 291   }
 292
 293   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 294
 295 #if WITH_PROFILE_MODEL_P
 296   if (PROFILE_MODEL_P (current_cpu))
 297     {
 298       m32rb_model_mark_get_h_gr (current_cpu, abuf);
 299       m32rb_model_mark_set_h_gr (current_cpu, abuf);
 300       m32rb_model_profile_insn (current_cpu, abuf);
 301     }
 302 #endif
 303
 304   return new_pc;
 305 #undef FLD
 306 }
 307
 308 /* addv: addv $dr,$sr.  */
 309
 310 CIA
 311 SEM_FN_NAME (m32rb,addv) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 312 {
 313 #define FLD(f) abuf->fields.fmt_addv.f
 314   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 315   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
 316
 317 do {
 318   UBI temp1;SI temp0;
 319   temp0 = ADDSI (* FLD (f_r1), * FLD (f_r2));
 320   temp1 = ADDOFSI (* FLD (f_r1), * FLD (f_r2), 0);
 321   {
 322     SI opval = temp0;
 323     * FLD (f_r1) = opval;
 324     TRACE_RESULT (current_cpu, "dr", 'x', opval);
 325   }
 326   {
 327     UBI opval = temp1;
 328     CPU (h_cond) = opval;
 329     TRACE_RESULT (current_cpu, "condbit", 'x', opval);
 330   }
 331 } while (0);
 332
 333   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 334
 335 #if WITH_PROFILE_MODEL_P
 336   if (PROFILE_MODEL_P (current_cpu))
 337     {
 338       m32rb_model_mark_get_h_gr (current_cpu, abuf);
 339       m32rb_model_mark_set_h_gr (current_cpu, abuf);
 340       m32rb_model_profile_insn (current_cpu, abuf);
 341     }
 342 #endif
 343
 344   return new_pc;
 345 #undef FLD
 346 }
 347
 348 /* addv3: addv3 $dr,$sr,$simm16.  */
 349
 350 CIA
 351 SEM_FN_NAME (m32rb,addv3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 352 {
 353 #define FLD(f) abuf->fields.fmt_addv3.f
 354   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 355   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 356
 357 do {
 358   UBI temp1;SI temp0;
 359   temp0 = ADDSI (* FLD (f_r2), FLD (f_simm16));
 360   temp1 = ADDOFSI (* FLD (f_r2), FLD (f_simm16), 0);
 361   {
 362     SI opval = temp0;
 363     * FLD (f_r1) = opval;
 364     TRACE_RESULT (current_cpu, "dr", 'x', opval);
 365   }
 366   {
 367     UBI opval = temp1;
 368     CPU (h_cond) = opval;
 369     TRACE_RESULT (current_cpu, "condbit", 'x', opval);
 370   }
 371 } while (0);
 372
 373   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 374
 375 #if WITH_PROFILE_MODEL_P
 376   if (PROFILE_MODEL_P (current_cpu))
 377     {
 378       m32rb_model_mark_get_h_gr (current_cpu, abuf);
 379       m32rb_model_mark_set_h_gr (current_cpu, abuf);
 380       m32rb_model_profile_insn (current_cpu, abuf);
 381     }
 382 #endif
 383
 384   return new_pc;
 385 #undef FLD
 386 }
 387
 388 /* addx: addx $dr,$sr.  */
 389
 390 CIA
 391 SEM_FN_NAME (m32rb,addx) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 392 {
 393 #define FLD(f) abuf->fields.fmt_addx.f
 394   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 395   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
 396
 397 do {
 398   UBI temp1;SI temp0;
 399   temp0 = ADDCSI (* FLD (f_r1), * FLD (f_r2), CPU (h_cond));
 400   temp1 = ADDCFSI (* FLD (f_r1), * FLD (f_r2), CPU (h_cond));
 401   {
 402     SI opval = temp0;
 403     * FLD (f_r1) = opval;
 404     TRACE_RESULT (current_cpu, "dr", 'x', opval);
 405   }
 406   {
 407     UBI opval = temp1;
 408     CPU (h_cond) = opval;
 409     TRACE_RESULT (current_cpu, "condbit", 'x', opval);
 410   }
 411 } while (0);
 412
 413   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 414
 415 #if WITH_PROFILE_MODEL_P
 416   if (PROFILE_MODEL_P (current_cpu))
 417     {
 418       m32rb_model_mark_get_h_gr (current_cpu, abuf);
 419       m32rb_model_mark_set_h_gr (current_cpu, abuf);
 420       m32rb_model_profile_insn (current_cpu, abuf);
 421     }
 422 #endif
 423
 424   return new_pc;
 425 #undef FLD
 426 }
 427
 428 /* bc8: bc.s $disp8.  */
 429
 430 CIA
 431 SEM_FN_NAME (m32rb,bc8) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 432 {
 433 #define FLD(f) abuf->fields.fmt_bc8.f
 434   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 435   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
 436   int taken_p = 0;
 437
 438 if (CPU (h_cond)) {
 439   {
 440     USI opval = FLD (f_disp8);
 441     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_CACHE (sem_arg, opval));
 442     taken_p = 1;
 443     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 444   }
 445 }
 446
 447   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 448
 449 #if WITH_PROFILE_MODEL_P
 450   if (PROFILE_MODEL_P (current_cpu))
 451     {
 452       m32rb_model_profile_cti_insn (current_cpu, abuf, taken_p);
 453     }
 454 #endif
 455
 456   return new_pc;
 457 #undef FLD
 458 }
 459
 460 /* bc24: bc.l $disp24.  */
 461
 462 CIA
 463 SEM_FN_NAME (m32rb,bc24) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 464 {
 465 #define FLD(f) abuf->fields.fmt_bc24.f
 466   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 467   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 468   int taken_p = 0;
 469
 470 if (CPU (h_cond)) {
 471   {
 472     USI opval = FLD (f_disp24);
 473     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_CACHE (sem_arg, opval));
 474     taken_p = 1;
 475     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 476   }
 477 }
 478
 479   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 480
 481 #if WITH_PROFILE_MODEL_P
 482   if (PROFILE_MODEL_P (current_cpu))
 483     {
 484       m32rb_model_profile_cti_insn (current_cpu, abuf, taken_p);
 485     }
 486 #endif
 487
 488   return new_pc;
 489 #undef FLD
 490 }
 491
 492 /* beq: beq $src1,$src2,$disp16.  */
 493
 494 CIA
 495 SEM_FN_NAME (m32rb,beq) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 496 {
 497 #define FLD(f) abuf->fields.fmt_beq.f
 498   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 499   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 500   int taken_p = 0;
 501
 502 if (EQSI (* FLD (f_r1), * FLD (f_r2))) {
 503   {
 504     USI opval = FLD (f_disp16);
 505     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_CACHE (sem_arg, opval));
 506     taken_p = 1;
 507     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 508   }
 509 }
 510
 511   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 512
 513 #if WITH_PROFILE_MODEL_P
 514   if (PROFILE_MODEL_P (current_cpu))
 515     {
 516       m32rb_model_mark_get_h_gr (current_cpu, abuf);
 517       m32rb_model_profile_cti_insn (current_cpu, abuf, taken_p);
 518     }
 519 #endif
 520
 521   return new_pc;
 522 #undef FLD
 523 }
 524
 525 /* beqz: beqz $src2,$disp16.  */
 526
 527 CIA
 528 SEM_FN_NAME (m32rb,beqz) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 529 {
 530 #define FLD(f) abuf->fields.fmt_beqz.f
 531   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 532   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 533   int taken_p = 0;
 534
 535 if (EQSI (* FLD (f_r2), 0)) {
 536   {
 537     USI opval = FLD (f_disp16);
 538     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_CACHE (sem_arg, opval));
 539     taken_p = 1;
 540     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 541   }
 542 }
 543
 544   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 545
 546 #if WITH_PROFILE_MODEL_P
 547   if (PROFILE_MODEL_P (current_cpu))
 548     {
 549       m32rb_model_mark_get_h_gr (current_cpu, abuf);
 550       m32rb_model_profile_cti_insn (current_cpu, abuf, taken_p);
 551     }
 552 #endif
 553
 554   return new_pc;
 555 #undef FLD
 556 }
 557
 558 /* bgez: bgez $src2,$disp16.  */
 559
 560 CIA
 561 SEM_FN_NAME (m32rb,bgez) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 562 {
 563 #define FLD(f) abuf->fields.fmt_beqz.f
 564   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 565   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 566   int taken_p = 0;
 567
 568 if (GESI (* FLD (f_r2), 0)) {
 569   {
 570     USI opval = FLD (f_disp16);
 571     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_CACHE (sem_arg, opval));
 572     taken_p = 1;
 573     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 574   }
 575 }
 576
 577   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 578
 579 #if WITH_PROFILE_MODEL_P
 580   if (PROFILE_MODEL_P (current_cpu))
 581     {
 582       m32rb_model_mark_get_h_gr (current_cpu, abuf);
 583       m32rb_model_profile_cti_insn (current_cpu, abuf, taken_p);
 584     }
 585 #endif
 586
 587   return new_pc;
 588 #undef FLD
 589 }
 590
 591 /* bgtz: bgtz $src2,$disp16.  */
 592
 593 CIA
 594 SEM_FN_NAME (m32rb,bgtz) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 595 {
 596 #define FLD(f) abuf->fields.fmt_beqz.f
 597   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 598   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 599   int taken_p = 0;
 600
 601 if (GTSI (* FLD (f_r2), 0)) {
 602   {
 603     USI opval = FLD (f_disp16);
 604     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_CACHE (sem_arg, opval));
 605     taken_p = 1;
 606     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 607   }
 608 }
 609
 610   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 611
 612 #if WITH_PROFILE_MODEL_P
 613   if (PROFILE_MODEL_P (current_cpu))
 614     {
 615       m32rb_model_mark_get_h_gr (current_cpu, abuf);
 616       m32rb_model_profile_cti_insn (current_cpu, abuf, taken_p);
 617     }
 618 #endif
 619
 620   return new_pc;
 621 #undef FLD
 622 }
 623
 624 /* blez: blez $src2,$disp16.  */
 625
 626 CIA
 627 SEM_FN_NAME (m32rb,blez) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 628 {
 629 #define FLD(f) abuf->fields.fmt_beqz.f
 630   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 631   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 632   int taken_p = 0;
 633
 634 if (LESI (* FLD (f_r2), 0)) {
 635   {
 636     USI opval = FLD (f_disp16);
 637     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_CACHE (sem_arg, opval));
 638     taken_p = 1;
 639     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 640   }
 641 }
 642
 643   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 644
 645 #if WITH_PROFILE_MODEL_P
 646   if (PROFILE_MODEL_P (current_cpu))
 647     {
 648       m32rb_model_mark_get_h_gr (current_cpu, abuf);
 649       m32rb_model_profile_cti_insn (current_cpu, abuf, taken_p);
 650     }
 651 #endif
 652
 653   return new_pc;
 654 #undef FLD
 655 }
 656
 657 /* bltz: bltz $src2,$disp16.  */
 658
 659 CIA
 660 SEM_FN_NAME (m32rb,bltz) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 661 {
 662 #define FLD(f) abuf->fields.fmt_beqz.f
 663   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 664   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 665   int taken_p = 0;
 666
 667 if (LTSI (* FLD (f_r2), 0)) {
 668   {
 669     USI opval = FLD (f_disp16);
 670     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_CACHE (sem_arg, opval));
 671     taken_p = 1;
 672     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 673   }
 674 }
 675
 676   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 677
 678 #if WITH_PROFILE_MODEL_P
 679   if (PROFILE_MODEL_P (current_cpu))
 680     {
 681       m32rb_model_mark_get_h_gr (current_cpu, abuf);
 682       m32rb_model_profile_cti_insn (current_cpu, abuf, taken_p);
 683     }
 684 #endif
 685
 686   return new_pc;
 687 #undef FLD
 688 }
 689
 690 /* bnez: bnez $src2,$disp16.  */
 691
 692 CIA
 693 SEM_FN_NAME (m32rb,bnez) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 694 {
 695 #define FLD(f) abuf->fields.fmt_beqz.f
 696   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 697   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 698   int taken_p = 0;
 699
 700 if (NESI (* FLD (f_r2), 0)) {
 701   {
 702     USI opval = FLD (f_disp16);
 703     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_CACHE (sem_arg, opval));
 704     taken_p = 1;
 705     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 706   }
 707 }
 708
 709   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 710
 711 #if WITH_PROFILE_MODEL_P
 712   if (PROFILE_MODEL_P (current_cpu))
 713     {
 714       m32rb_model_mark_get_h_gr (current_cpu, abuf);
 715       m32rb_model_profile_cti_insn (current_cpu, abuf, taken_p);
 716     }
 717 #endif
 718
 719   return new_pc;
 720 #undef FLD
 721 }
 722
 723 /* bl8: bl.s $disp8.  */
 724
 725 CIA
 726 SEM_FN_NAME (m32rb,bl8) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 727 {
 728 #define FLD(f) abuf->fields.fmt_bl8.f
 729   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 730   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
 731   int taken_p = 0;
 732
 733 do {
 734   {
 735     SI opval = ADDSI (ANDSI (CPU (h_pc), -4), 4);
 736     CPU (h_gr[((HOSTUINT) 14)]) = opval;
 737     TRACE_RESULT (current_cpu, "gr-14", 'x', opval);
 738   }
 739   {
 740     USI opval = FLD (f_disp8);
 741     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_CACHE (sem_arg, opval));
 742     taken_p = 1;
 743     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 744   }
 745 } while (0);
 746
 747   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 748
 749 #if WITH_PROFILE_MODEL_P
 750   if (PROFILE_MODEL_P (current_cpu))
 751     {
 752       m32rb_model_mark_set_h_gr (current_cpu, abuf);
 753       m32rb_model_profile_cti_insn (current_cpu, abuf, taken_p);
 754     }
 755 #endif
 756
 757   return new_pc;
 758 #undef FLD
 759 }
 760
 761 /* bl24: bl.l $disp24.  */
 762
 763 CIA
 764 SEM_FN_NAME (m32rb,bl24) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 765 {
 766 #define FLD(f) abuf->fields.fmt_bl24.f
 767   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 768   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 769   int taken_p = 0;
 770
 771 do {
 772   {
 773     SI opval = ADDSI (CPU (h_pc), 4);
 774     CPU (h_gr[((HOSTUINT) 14)]) = opval;
 775     TRACE_RESULT (current_cpu, "gr-14", 'x', opval);
 776   }
 777   {
 778     USI opval = FLD (f_disp24);
 779     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_CACHE (sem_arg, opval));
 780     taken_p = 1;
 781     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 782   }
 783 } while (0);
 784
 785   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 786
 787 #if WITH_PROFILE_MODEL_P
 788   if (PROFILE_MODEL_P (current_cpu))
 789     {
 790       m32rb_model_mark_set_h_gr (current_cpu, abuf);
 791       m32rb_model_profile_cti_insn (current_cpu, abuf, taken_p);
 792     }
 793 #endif
 794
 795   return new_pc;
 796 #undef FLD
 797 }
 798
 799 /* bnc8: bnc.s $disp8.  */
 800
 801 CIA
 802 SEM_FN_NAME (m32rb,bnc8) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 803 {
 804 #define FLD(f) abuf->fields.fmt_bc8.f
 805   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 806   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
 807   int taken_p = 0;
 808
 809 if (NOTBI (CPU (h_cond))) {
 810   {
 811     USI opval = FLD (f_disp8);
 812     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_CACHE (sem_arg, opval));
 813     taken_p = 1;
 814     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 815   }
 816 }
 817
 818   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 819
 820 #if WITH_PROFILE_MODEL_P
 821   if (PROFILE_MODEL_P (current_cpu))
 822     {
 823       m32rb_model_profile_cti_insn (current_cpu, abuf, taken_p);
 824     }
 825 #endif
 826
 827   return new_pc;
 828 #undef FLD
 829 }
 830
 831 /* bnc24: bnc.l $disp24.  */
 832
 833 CIA
 834 SEM_FN_NAME (m32rb,bnc24) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 835 {
 836 #define FLD(f) abuf->fields.fmt_bc24.f
 837   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 838   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 839   int taken_p = 0;
 840
 841 if (NOTBI (CPU (h_cond))) {
 842   {
 843     USI opval = FLD (f_disp24);
 844     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_CACHE (sem_arg, opval));
 845     taken_p = 1;
 846     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 847   }
 848 }
 849
 850   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 851
 852 #if WITH_PROFILE_MODEL_P
 853   if (PROFILE_MODEL_P (current_cpu))
 854     {
 855       m32rb_model_profile_cti_insn (current_cpu, abuf, taken_p);
 856     }
 857 #endif
 858
 859   return new_pc;
 860 #undef FLD
 861 }
 862
 863 /* bne: bne $src1,$src2,$disp16.  */
 864
 865 CIA
 866 SEM_FN_NAME (m32rb,bne) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 867 {
 868 #define FLD(f) abuf->fields.fmt_beq.f
 869   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 870   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 871   int taken_p = 0;
 872
 873 if (NESI (* FLD (f_r1), * FLD (f_r2))) {
 874   {
 875     USI opval = FLD (f_disp16);
 876     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_CACHE (sem_arg, opval));
 877     taken_p = 1;
 878     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 879   }
 880 }
 881
 882   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 883
 884 #if WITH_PROFILE_MODEL_P
 885   if (PROFILE_MODEL_P (current_cpu))
 886     {
 887       m32rb_model_mark_get_h_gr (current_cpu, abuf);
 888       m32rb_model_profile_cti_insn (current_cpu, abuf, taken_p);
 889     }
 890 #endif
 891
 892   return new_pc;
 893 #undef FLD
 894 }
 895
 896 /* bra8: bra.s $disp8.  */
 897
 898 CIA
 899 SEM_FN_NAME (m32rb,bra8) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 900 {
 901 #define FLD(f) abuf->fields.fmt_bra8.f
 902   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 903   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
 904   int taken_p = 0;
 905
 906   {
 907     USI opval = FLD (f_disp8);
 908     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_CACHE (sem_arg, opval));
 909     taken_p = 1;
 910     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 911   }
 912
 913   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 914
 915 #if WITH_PROFILE_MODEL_P
 916   if (PROFILE_MODEL_P (current_cpu))
 917     {
 918       m32rb_model_profile_cti_insn (current_cpu, abuf, taken_p);
 919     }
 920 #endif
 921
 922   return new_pc;
 923 #undef FLD
 924 }
 925
 926 /* bra24: bra.l $disp24.  */
 927
 928 CIA
 929 SEM_FN_NAME (m32rb,bra24) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 930 {
 931 #define FLD(f) abuf->fields.fmt_bra24.f
 932   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 933   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 934   int taken_p = 0;
 935
 936   {
 937     USI opval = FLD (f_disp24);
 938     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_CACHE (sem_arg, opval));
 939     taken_p = 1;
 940     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 941   }
 942
 943   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 944
 945 #if WITH_PROFILE_MODEL_P
 946   if (PROFILE_MODEL_P (current_cpu))
 947     {
 948       m32rb_model_profile_cti_insn (current_cpu, abuf, taken_p);
 949     }
 950 #endif
 951
 952   return new_pc;
 953 #undef FLD
 954 }
 955
 956 /* cmp: cmp $src1,$src2.  */
 957
 958 CIA
 959 SEM_FN_NAME (m32rb,cmp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 960 {
 961 #define FLD(f) abuf->fields.fmt_cmp.f
 962   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 963   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
 964
 965   {
 966     UBI opval = LTSI (* FLD (f_r1), * FLD (f_r2));
 967     CPU (h_cond) = opval;
 968     TRACE_RESULT (current_cpu, "condbit", 'x', opval);
 969   }
 970
 971   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 972
 973 #if WITH_PROFILE_MODEL_P
 974   if (PROFILE_MODEL_P (current_cpu))
 975     {
 976       m32rb_model_mark_get_h_gr (current_cpu, abuf);
 977       m32rb_model_profile_insn (current_cpu, abuf);
 978     }
 979 #endif
 980
 981   return new_pc;
 982 #undef FLD
 983 }
 984
 985 /* cmpi: cmpi $src2,$simm16.  */
 986
 987 CIA
 988 SEM_FN_NAME (m32rb,cmpi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 989 {
 990 #define FLD(f) abuf->fields.fmt_cmpi.f
 991   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 992   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 993
 994   {
 995     UBI opval = LTSI (* FLD (f_r2), FLD (f_simm16));
 996     CPU (h_cond) = opval;
 997     TRACE_RESULT (current_cpu, "condbit", 'x', opval);
 998   }
 999
1000   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1001
1002 #if WITH_PROFILE_MODEL_P
1003   if (PROFILE_MODEL_P (current_cpu))
1004     {
1005       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1006       m32rb_model_profile_insn (current_cpu, abuf);
1007     }
1008 #endif
1009
1010   return new_pc;
1011 #undef FLD
1012 }
1013
1014 /* cmpu: cmpu $src1,$src2.  */
1015
1016 CIA
1017 SEM_FN_NAME (m32rb,cmpu) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1018 {
1019 #define FLD(f) abuf->fields.fmt_cmp.f
1020   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1021   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1022
1023   {
1024     UBI opval = LTUSI (* FLD (f_r1), * FLD (f_r2));
1025     CPU (h_cond) = opval;
1026     TRACE_RESULT (current_cpu, "condbit", 'x', opval);
1027   }
1028
1029   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1030
1031 #if WITH_PROFILE_MODEL_P
1032   if (PROFILE_MODEL_P (current_cpu))
1033     {
1034       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1035       m32rb_model_profile_insn (current_cpu, abuf);
1036     }
1037 #endif
1038
1039   return new_pc;
1040 #undef FLD
1041 }
1042
1043 /* cmpui: cmpui $src2,$simm16.  */
1044
1045 CIA
1046 SEM_FN_NAME (m32rb,cmpui) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1047 {
1048 #define FLD(f) abuf->fields.fmt_cmpi.f
1049   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1050   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1051
1052   {
1053     UBI opval = LTUSI (* FLD (f_r2), FLD (f_simm16));
1054     CPU (h_cond) = opval;
1055     TRACE_RESULT (current_cpu, "condbit", 'x', opval);
1056   }
1057
1058   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1059
1060 #if WITH_PROFILE_MODEL_P
1061   if (PROFILE_MODEL_P (current_cpu))
1062     {
1063       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1064       m32rb_model_profile_insn (current_cpu, abuf);
1065     }
1066 #endif
1067
1068   return new_pc;
1069 #undef FLD
1070 }
1071
1072 /* div: div $dr,$sr.  */
1073
1074 CIA
1075 SEM_FN_NAME (m32rb,div) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1076 {
1077 #define FLD(f) abuf->fields.fmt_div.f
1078   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1079   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1080
1081 if (NESI (* FLD (f_r2), 0)) {
1082   {
1083     SI opval = DIVSI (* FLD (f_r1), * FLD (f_r2));
1084     * FLD (f_r1) = opval;
1085     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1086   }
1087 }
1088
1089   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1090
1091 #if WITH_PROFILE_MODEL_P
1092   if (PROFILE_MODEL_P (current_cpu))
1093     {
1094       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1095       m32rb_model_mark_set_h_gr (current_cpu, abuf);
1096       m32rb_model_profile_insn (current_cpu, abuf);
1097     }
1098 #endif
1099
1100   return new_pc;
1101 #undef FLD
1102 }
1103
1104 /* divu: divu $dr,$sr.  */
1105
1106 CIA
1107 SEM_FN_NAME (m32rb,divu) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1108 {
1109 #define FLD(f) abuf->fields.fmt_div.f
1110   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1111   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1112
1113 if (NESI (* FLD (f_r2), 0)) {
1114   {
1115     SI opval = UDIVSI (* FLD (f_r1), * FLD (f_r2));
1116     * FLD (f_r1) = opval;
1117     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1118   }
1119 }
1120
1121   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1122
1123 #if WITH_PROFILE_MODEL_P
1124   if (PROFILE_MODEL_P (current_cpu))
1125     {
1126       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1127       m32rb_model_mark_set_h_gr (current_cpu, abuf);
1128       m32rb_model_profile_insn (current_cpu, abuf);
1129     }
1130 #endif
1131
1132   return new_pc;
1133 #undef FLD
1134 }
1135
1136 /* rem: rem $dr,$sr.  */
1137
1138 CIA
1139 SEM_FN_NAME (m32rb,rem) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1140 {
1141 #define FLD(f) abuf->fields.fmt_div.f
1142   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1143   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1144
1145 if (NESI (* FLD (f_r2), 0)) {
1146   {
1147     SI opval = MODSI (* FLD (f_r1), * FLD (f_r2));
1148     * FLD (f_r1) = opval;
1149     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1150   }
1151 }
1152
1153   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1154
1155 #if WITH_PROFILE_MODEL_P
1156   if (PROFILE_MODEL_P (current_cpu))
1157     {
1158       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1159       m32rb_model_mark_set_h_gr (current_cpu, abuf);
1160       m32rb_model_profile_insn (current_cpu, abuf);
1161     }
1162 #endif
1163
1164   return new_pc;
1165 #undef FLD
1166 }
1167
1168 /* remu: remu $dr,$sr.  */
1169
1170 CIA
1171 SEM_FN_NAME (m32rb,remu) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1172 {
1173 #define FLD(f) abuf->fields.fmt_div.f
1174   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1175   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1176
1177 if (NESI (* FLD (f_r2), 0)) {
1178   {
1179     SI opval = UMODSI (* FLD (f_r1), * FLD (f_r2));
1180     * FLD (f_r1) = opval;
1181     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1182   }
1183 }
1184
1185   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1186
1187 #if WITH_PROFILE_MODEL_P
1188   if (PROFILE_MODEL_P (current_cpu))
1189     {
1190       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1191       m32rb_model_mark_set_h_gr (current_cpu, abuf);
1192       m32rb_model_profile_insn (current_cpu, abuf);
1193     }
1194 #endif
1195
1196   return new_pc;
1197 #undef FLD
1198 }
1199
1200 /* jl: jl $sr.  */
1201
1202 CIA
1203 SEM_FN_NAME (m32rb,jl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1204 {
1205 #define FLD(f) abuf->fields.fmt_jl.f
1206   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1207   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1208   int taken_p = 0;
1209
1210 do {
1211   USI temp1;SI temp0;
1212   temp0 = ADDSI (ANDSI (CPU (h_pc), -4), 4);
1213   temp1 = ANDSI (* FLD (f_r2), -4);
1214   {
1215     SI opval = temp0;
1216     CPU (h_gr[((HOSTUINT) 14)]) = opval;
1217     TRACE_RESULT (current_cpu, "gr-14", 'x', opval);
1218   }
1219   {
1220     USI opval = temp1;
1221     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
1222     taken_p = 1;
1223     TRACE_RESULT (current_cpu, "pc", 'x', opval);
1224   }
1225 } while (0);
1226
1227   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1228
1229 #if WITH_PROFILE_MODEL_P
1230   if (PROFILE_MODEL_P (current_cpu))
1231     {
1232       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1233       m32rb_model_mark_set_h_gr (current_cpu, abuf);
1234       m32rb_model_profile_cti_insn (current_cpu, abuf, taken_p);
1235     }
1236 #endif
1237
1238   return new_pc;
1239 #undef FLD
1240 }
1241
1242 /* jmp: jmp $sr.  */
1243
1244 CIA
1245 SEM_FN_NAME (m32rb,jmp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1246 {
1247 #define FLD(f) abuf->fields.fmt_jmp.f
1248   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1249   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1250   int taken_p = 0;
1251
1252   {
1253     USI opval = ANDSI (* FLD (f_r2), -4);
1254     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
1255     taken_p = 1;
1256     TRACE_RESULT (current_cpu, "pc", 'x', opval);
1257   }
1258
1259   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1260
1261 #if WITH_PROFILE_MODEL_P
1262   if (PROFILE_MODEL_P (current_cpu))
1263     {
1264       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1265       m32rb_model_profile_cti_insn (current_cpu, abuf, taken_p);
1266     }
1267 #endif
1268
1269   return new_pc;
1270 #undef FLD
1271 }
1272
1273 /* ld: ld $dr,@$sr.  */
1274
1275 CIA
1276 SEM_FN_NAME (m32rb,ld) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1277 {
1278 #define FLD(f) abuf->fields.fmt_ld.f
1279   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1280   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1281
1282   {
1283     SI opval = GETMEMSI (current_cpu, * FLD (f_r2));
1284     * FLD (f_r1) = opval;
1285     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1286   }
1287
1288   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1289
1290 #if WITH_PROFILE_MODEL_P
1291   if (PROFILE_MODEL_P (current_cpu))
1292     {
1293       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1294       m32rb_model_mark_set_h_gr (current_cpu, abuf);
1295       m32rb_model_profile_insn (current_cpu, abuf);
1296     }
1297 #endif
1298
1299   return new_pc;
1300 #undef FLD
1301 }
1302
1303 /* ld-d: ld $dr,@($slo16,$sr).  */
1304
1305 CIA
1306 SEM_FN_NAME (m32rb,ld_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1307 {
1308 #define FLD(f) abuf->fields.fmt_ld_d.f
1309   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1310   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1311
1312   {
1313     SI opval = GETMEMSI (current_cpu, ADDSI (* FLD (f_r2), FLD (f_simm16)));
1314     * FLD (f_r1) = opval;
1315     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1316   }
1317
1318   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1319
1320 #if WITH_PROFILE_MODEL_P
1321   if (PROFILE_MODEL_P (current_cpu))
1322     {
1323       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1324       m32rb_model_mark_set_h_gr (current_cpu, abuf);
1325       m32rb_model_profile_insn (current_cpu, abuf);
1326     }
1327 #endif
1328
1329   return new_pc;
1330 #undef FLD
1331 }
1332
1333 /* ldb: ldb $dr,@$sr.  */
1334
1335 CIA
1336 SEM_FN_NAME (m32rb,ldb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1337 {
1338 #define FLD(f) abuf->fields.fmt_ldb.f
1339   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1340   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1341
1342   {
1343     SI opval = EXTQISI (GETMEMQI (current_cpu, * FLD (f_r2)));
1344     * FLD (f_r1) = opval;
1345     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1346   }
1347
1348   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1349
1350 #if WITH_PROFILE_MODEL_P
1351   if (PROFILE_MODEL_P (current_cpu))
1352     {
1353       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1354       m32rb_model_mark_set_h_gr (current_cpu, abuf);
1355       m32rb_model_profile_insn (current_cpu, abuf);
1356     }
1357 #endif
1358
1359   return new_pc;
1360 #undef FLD
1361 }
1362
1363 /* ldb-d: ldb $dr,@($slo16,$sr).  */
1364
1365 CIA
1366 SEM_FN_NAME (m32rb,ldb_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1367 {
1368 #define FLD(f) abuf->fields.fmt_ldb_d.f
1369   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1370   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1371
1372   {
1373     SI opval = EXTQISI (GETMEMQI (current_cpu, ADDSI (* FLD (f_r2), FLD (f_simm16))));
1374     * FLD (f_r1) = opval;
1375     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1376   }
1377
1378   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1379
1380 #if WITH_PROFILE_MODEL_P
1381   if (PROFILE_MODEL_P (current_cpu))
1382     {
1383       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1384       m32rb_model_mark_set_h_gr (current_cpu, abuf);
1385       m32rb_model_profile_insn (current_cpu, abuf);
1386     }
1387 #endif
1388
1389   return new_pc;
1390 #undef FLD
1391 }
1392
1393 /* ldh: ldh $dr,@$sr.  */
1394
1395 CIA
1396 SEM_FN_NAME (m32rb,ldh) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1397 {
1398 #define FLD(f) abuf->fields.fmt_ldh.f
1399   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1400   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1401
1402   {
1403     SI opval = EXTHISI (GETMEMHI (current_cpu, * FLD (f_r2)));
1404     * FLD (f_r1) = opval;
1405     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1406   }
1407
1408   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1409
1410 #if WITH_PROFILE_MODEL_P
1411   if (PROFILE_MODEL_P (current_cpu))
1412     {
1413       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1414       m32rb_model_mark_set_h_gr (current_cpu, abuf);
1415       m32rb_model_profile_insn (current_cpu, abuf);
1416     }
1417 #endif
1418
1419   return new_pc;
1420 #undef FLD
1421 }
1422
1423 /* ldh-d: ldh $dr,@($slo16,$sr).  */
1424
1425 CIA
1426 SEM_FN_NAME (m32rb,ldh_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1427 {
1428 #define FLD(f) abuf->fields.fmt_ldh_d.f
1429   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1430   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1431
1432   {
1433     SI opval = EXTHISI (GETMEMHI (current_cpu, ADDSI (* FLD (f_r2), FLD (f_simm16))));
1434     * FLD (f_r1) = opval;
1435     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1436   }
1437
1438   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1439
1440 #if WITH_PROFILE_MODEL_P
1441   if (PROFILE_MODEL_P (current_cpu))
1442     {
1443       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1444       m32rb_model_mark_set_h_gr (current_cpu, abuf);
1445       m32rb_model_profile_insn (current_cpu, abuf);
1446     }
1447 #endif
1448
1449   return new_pc;
1450 #undef FLD
1451 }
1452
1453 /* ldub: ldub $dr,@$sr.  */
1454
1455 CIA
1456 SEM_FN_NAME (m32rb,ldub) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1457 {
1458 #define FLD(f) abuf->fields.fmt_ldb.f
1459   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1460   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1461
1462   {
1463     SI opval = ZEXTQISI (GETMEMQI (current_cpu, * FLD (f_r2)));
1464     * FLD (f_r1) = opval;
1465     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1466   }
1467
1468   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1469
1470 #if WITH_PROFILE_MODEL_P
1471   if (PROFILE_MODEL_P (current_cpu))
1472     {
1473       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1474       m32rb_model_mark_set_h_gr (current_cpu, abuf);
1475       m32rb_model_profile_insn (current_cpu, abuf);
1476     }
1477 #endif
1478
1479   return new_pc;
1480 #undef FLD
1481 }
1482
1483 /* ldub-d: ldub $dr,@($slo16,$sr).  */
1484
1485 CIA
1486 SEM_FN_NAME (m32rb,ldub_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1487 {
1488 #define FLD(f) abuf->fields.fmt_ldb_d.f
1489   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1490   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1491
1492   {
1493     SI opval = ZEXTQISI (GETMEMQI (current_cpu, ADDSI (* FLD (f_r2), FLD (f_simm16))));
1494     * FLD (f_r1) = opval;
1495     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1496   }
1497
1498   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1499
1500 #if WITH_PROFILE_MODEL_P
1501   if (PROFILE_MODEL_P (current_cpu))
1502     {
1503       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1504       m32rb_model_mark_set_h_gr (current_cpu, abuf);
1505       m32rb_model_profile_insn (current_cpu, abuf);
1506     }
1507 #endif
1508
1509   return new_pc;
1510 #undef FLD
1511 }
1512
1513 /* lduh: lduh $dr,@$sr.  */
1514
1515 CIA
1516 SEM_FN_NAME (m32rb,lduh) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1517 {
1518 #define FLD(f) abuf->fields.fmt_ldh.f
1519   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1520   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1521
1522   {
1523     SI opval = ZEXTHISI (GETMEMHI (current_cpu, * FLD (f_r2)));
1524     * FLD (f_r1) = opval;
1525     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1526   }
1527
1528   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1529
1530 #if WITH_PROFILE_MODEL_P
1531   if (PROFILE_MODEL_P (current_cpu))
1532     {
1533       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1534       m32rb_model_mark_set_h_gr (current_cpu, abuf);
1535       m32rb_model_profile_insn (current_cpu, abuf);
1536     }
1537 #endif
1538
1539   return new_pc;
1540 #undef FLD
1541 }
1542
1543 /* lduh-d: lduh $dr,@($slo16,$sr).  */
1544
1545 CIA
1546 SEM_FN_NAME (m32rb,lduh_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1547 {
1548 #define FLD(f) abuf->fields.fmt_ldh_d.f
1549   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1550   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1551
1552   {
1553     SI opval = ZEXTHISI (GETMEMHI (current_cpu, ADDSI (* FLD (f_r2), FLD (f_simm16))));
1554     * FLD (f_r1) = opval;
1555     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1556   }
1557
1558   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1559
1560 #if WITH_PROFILE_MODEL_P
1561   if (PROFILE_MODEL_P (current_cpu))
1562     {
1563       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1564       m32rb_model_mark_set_h_gr (current_cpu, abuf);
1565       m32rb_model_profile_insn (current_cpu, abuf);
1566     }
1567 #endif
1568
1569   return new_pc;
1570 #undef FLD
1571 }
1572
1573 /* ld-plus: ld $dr,@$sr+.  */
1574
1575 CIA
1576 SEM_FN_NAME (m32rb,ld_plus) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1577 {
1578 #define FLD(f) abuf->fields.fmt_ld_plus.f
1579   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1580   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1581
1582 do {
1583   SI temp1;SI temp0;
1584   temp0 = GETMEMSI (current_cpu, * FLD (f_r2));
1585   temp1 = ADDSI (* FLD (f_r2), 4);
1586   {
1587     SI opval = temp0;
1588     * FLD (f_r1) = opval;
1589     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1590   }
1591   {
1592     SI opval = temp1;
1593     * FLD (f_r2) = opval;
1594     TRACE_RESULT (current_cpu, "sr", 'x', opval);
1595   }
1596 } while (0);
1597
1598   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1599
1600 #if WITH_PROFILE_MODEL_P
1601   if (PROFILE_MODEL_P (current_cpu))
1602     {
1603       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1604       m32rb_model_mark_set_h_gr (current_cpu, abuf);
1605       m32rb_model_profile_insn (current_cpu, abuf);
1606     }
1607 #endif
1608
1609   return new_pc;
1610 #undef FLD
1611 }
1612
1613 /* ld24: ld24 $dr,$uimm24.  */
1614
1615 CIA
1616 SEM_FN_NAME (m32rb,ld24) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1617 {
1618 #define FLD(f) abuf->fields.fmt_ld24.f
1619   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1620   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1621
1622   {
1623     SI opval = FLD (f_uimm24);
1624     * FLD (f_r1) = opval;
1625     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1626   }
1627
1628   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1629
1630 #if WITH_PROFILE_MODEL_P
1631   if (PROFILE_MODEL_P (current_cpu))
1632     {
1633       m32rb_model_mark_set_h_gr (current_cpu, abuf);
1634       m32rb_model_profile_insn (current_cpu, abuf);
1635     }
1636 #endif
1637
1638   return new_pc;
1639 #undef FLD
1640 }
1641
1642 /* ldi8: ldi8 $dr,$simm8.  */
1643
1644 CIA
1645 SEM_FN_NAME (m32rb,ldi8) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1646 {
1647 #define FLD(f) abuf->fields.fmt_ldi8.f
1648   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1649   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1650
1651   {
1652     SI opval = FLD (f_simm8);
1653     * FLD (f_r1) = opval;
1654     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1655   }
1656
1657   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1658
1659 #if WITH_PROFILE_MODEL_P
1660   if (PROFILE_MODEL_P (current_cpu))
1661     {
1662       m32rb_model_mark_set_h_gr (current_cpu, abuf);
1663       m32rb_model_profile_insn (current_cpu, abuf);
1664     }
1665 #endif
1666
1667   return new_pc;
1668 #undef FLD
1669 }
1670
1671 /* ldi16: ldi16 $dr,$hash$slo16.  */
1672
1673 CIA
1674 SEM_FN_NAME (m32rb,ldi16) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1675 {
1676 #define FLD(f) abuf->fields.fmt_ldi16.f
1677   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1678   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1679
1680   {
1681     SI opval = FLD (f_simm16);
1682     * FLD (f_r1) = opval;
1683     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1684   }
1685
1686   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1687
1688 #if WITH_PROFILE_MODEL_P
1689   if (PROFILE_MODEL_P (current_cpu))
1690     {
1691       m32rb_model_mark_set_h_gr (current_cpu, abuf);
1692       m32rb_model_profile_insn (current_cpu, abuf);
1693     }
1694 #endif
1695
1696   return new_pc;
1697 #undef FLD
1698 }
1699
1700 /* lock: lock $dr,@$sr.  */
1701
1702 CIA
1703 SEM_FN_NAME (m32rb,lock) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1704 {
1705 #define FLD(f) abuf->fields.fmt_lock.f
1706   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1707   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1708
1709 do {
1710   {
1711     UBI opval = 1;
1712     CPU (h_lock) = opval;
1713     TRACE_RESULT (current_cpu, "lock-0", 'x', opval);
1714   }
1715   {
1716     SI opval = GETMEMSI (current_cpu, * FLD (f_r2));
1717     * FLD (f_r1) = opval;
1718     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1719   }
1720 } while (0);
1721
1722   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1723
1724 #if WITH_PROFILE_MODEL_P
1725   if (PROFILE_MODEL_P (current_cpu))
1726     {
1727       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1728       m32rb_model_mark_set_h_gr (current_cpu, abuf);
1729       m32rb_model_profile_insn (current_cpu, abuf);
1730     }
1731 #endif
1732
1733   return new_pc;
1734 #undef FLD
1735 }
1736
1737 /* machi: machi $src1,$src2.  */
1738
1739 CIA
1740 SEM_FN_NAME (m32rb,machi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1741 {
1742 #define FLD(f) abuf->fields.fmt_machi.f
1743   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1744   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1745
1746   {
1747     DI opval = SRADI (SLLDI (ADDDI (m32rb_h_accum_get (current_cpu), MULDI (EXTSIDI (ANDSI (* FLD (f_r1), 0xffff0000)), EXTHIDI (TRUNCSIHI (SRASI (* FLD (f_r2), 16))))), 8), 8);
1748     m32rb_h_accum_set (current_cpu, opval);
1749     TRACE_RESULT (current_cpu, "accum", 'D', opval);
1750   }
1751
1752   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1753
1754 #if WITH_PROFILE_MODEL_P
1755   if (PROFILE_MODEL_P (current_cpu))
1756     {
1757       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1758       m32rb_model_profile_insn (current_cpu, abuf);
1759     }
1760 #endif
1761
1762   return new_pc;
1763 #undef FLD
1764 }
1765
1766 /* maclo: maclo $src1,$src2.  */
1767
1768 CIA
1769 SEM_FN_NAME (m32rb,maclo) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1770 {
1771 #define FLD(f) abuf->fields.fmt_machi.f
1772   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1773   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1774
1775   {
1776     DI opval = SRADI (SLLDI (ADDDI (m32rb_h_accum_get (current_cpu), MULDI (EXTSIDI (SLLSI (* FLD (f_r1), 16)), EXTHIDI (TRUNCSIHI (* FLD (f_r2))))), 8), 8);
1777     m32rb_h_accum_set (current_cpu, opval);
1778     TRACE_RESULT (current_cpu, "accum", 'D', opval);
1779   }
1780
1781   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1782
1783 #if WITH_PROFILE_MODEL_P
1784   if (PROFILE_MODEL_P (current_cpu))
1785     {
1786       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1787       m32rb_model_profile_insn (current_cpu, abuf);
1788     }
1789 #endif
1790
1791   return new_pc;
1792 #undef FLD
1793 }
1794
1795 /* macwhi: macwhi $src1,$src2.  */
1796
1797 CIA
1798 SEM_FN_NAME (m32rb,macwhi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1799 {
1800 #define FLD(f) abuf->fields.fmt_machi.f
1801   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1802   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1803
1804   {
1805     DI opval = SRADI (SLLDI (ADDDI (m32rb_h_accum_get (current_cpu), MULDI (EXTSIDI (* FLD (f_r1)), EXTHIDI (TRUNCSIHI (SRASI (* FLD (f_r2), 16))))), 8), 8);
1806     m32rb_h_accum_set (current_cpu, opval);
1807     TRACE_RESULT (current_cpu, "accum", 'D', opval);
1808   }
1809
1810   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1811
1812 #if WITH_PROFILE_MODEL_P
1813   if (PROFILE_MODEL_P (current_cpu))
1814     {
1815       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1816       m32rb_model_profile_insn (current_cpu, abuf);
1817     }
1818 #endif
1819
1820   return new_pc;
1821 #undef FLD
1822 }
1823
1824 /* macwlo: macwlo $src1,$src2.  */
1825
1826 CIA
1827 SEM_FN_NAME (m32rb,macwlo) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1828 {
1829 #define FLD(f) abuf->fields.fmt_machi.f
1830   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1831   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1832
1833   {
1834     DI opval = SRADI (SLLDI (ADDDI (m32rb_h_accum_get (current_cpu), MULDI (EXTSIDI (* FLD (f_r1)), EXTHIDI (TRUNCSIHI (* FLD (f_r2))))), 8), 8);
1835     m32rb_h_accum_set (current_cpu, opval);
1836     TRACE_RESULT (current_cpu, "accum", 'D', opval);
1837   }
1838
1839   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1840
1841 #if WITH_PROFILE_MODEL_P
1842   if (PROFILE_MODEL_P (current_cpu))
1843     {
1844       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1845       m32rb_model_profile_insn (current_cpu, abuf);
1846     }
1847 #endif
1848
1849   return new_pc;
1850 #undef FLD
1851 }
1852
1853 /* mul: mul $dr,$sr.  */
1854
1855 CIA
1856 SEM_FN_NAME (m32rb,mul) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1857 {
1858 #define FLD(f) abuf->fields.fmt_add.f
1859   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1860   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1861
1862   {
1863     SI opval = MULSI (* FLD (f_r1), * FLD (f_r2));
1864     * FLD (f_r1) = opval;
1865     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1866   }
1867
1868   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1869
1870 #if WITH_PROFILE_MODEL_P
1871   if (PROFILE_MODEL_P (current_cpu))
1872     {
1873       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1874       m32rb_model_mark_set_h_gr (current_cpu, abuf);
1875       m32rb_model_profile_insn (current_cpu, abuf);
1876     }
1877 #endif
1878
1879   return new_pc;
1880 #undef FLD
1881 }
1882
1883 /* mulhi: mulhi $src1,$src2.  */
1884
1885 CIA
1886 SEM_FN_NAME (m32rb,mulhi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1887 {
1888 #define FLD(f) abuf->fields.fmt_mulhi.f
1889   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1890   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1891
1892   {
1893     DI opval = SRADI (SLLDI (MULDI (EXTSIDI (ANDSI (* FLD (f_r1), 0xffff0000)), EXTHIDI (TRUNCSIHI (SRASI (* FLD (f_r2), 16)))), 16), 16);
1894     m32rb_h_accum_set (current_cpu, opval);
1895     TRACE_RESULT (current_cpu, "accum", 'D', opval);
1896   }
1897
1898   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1899
1900 #if WITH_PROFILE_MODEL_P
1901   if (PROFILE_MODEL_P (current_cpu))
1902     {
1903       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1904       m32rb_model_profile_insn (current_cpu, abuf);
1905     }
1906 #endif
1907
1908   return new_pc;
1909 #undef FLD
1910 }
1911
1912 /* mullo: mullo $src1,$src2.  */
1913
1914 CIA
1915 SEM_FN_NAME (m32rb,mullo) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1916 {
1917 #define FLD(f) abuf->fields.fmt_mulhi.f
1918   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1919   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1920
1921   {
1922     DI opval = SRADI (SLLDI (MULDI (EXTSIDI (SLLSI (* FLD (f_r1), 16)), EXTHIDI (TRUNCSIHI (* FLD (f_r2)))), 16), 16);
1923     m32rb_h_accum_set (current_cpu, opval);
1924     TRACE_RESULT (current_cpu, "accum", 'D', opval);
1925   }
1926
1927   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1928
1929 #if WITH_PROFILE_MODEL_P
1930   if (PROFILE_MODEL_P (current_cpu))
1931     {
1932       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1933       m32rb_model_profile_insn (current_cpu, abuf);
1934     }
1935 #endif
1936
1937   return new_pc;
1938 #undef FLD
1939 }
1940
1941 /* mulwhi: mulwhi $src1,$src2.  */
1942
1943 CIA
1944 SEM_FN_NAME (m32rb,mulwhi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1945 {
1946 #define FLD(f) abuf->fields.fmt_mulhi.f
1947   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1948   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1949
1950   {
1951     DI opval = SRADI (SLLDI (MULDI (EXTSIDI (* FLD (f_r1)), EXTHIDI (TRUNCSIHI (SRASI (* FLD (f_r2), 16)))), 8), 8);
1952     m32rb_h_accum_set (current_cpu, opval);
1953     TRACE_RESULT (current_cpu, "accum", 'D', opval);
1954   }
1955
1956   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1957
1958 #if WITH_PROFILE_MODEL_P
1959   if (PROFILE_MODEL_P (current_cpu))
1960     {
1961       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1962       m32rb_model_profile_insn (current_cpu, abuf);
1963     }
1964 #endif
1965
1966   return new_pc;
1967 #undef FLD
1968 }
1969
1970 /* mulwlo: mulwlo $src1,$src2.  */
1971
1972 CIA
1973 SEM_FN_NAME (m32rb,mulwlo) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1974 {
1975 #define FLD(f) abuf->fields.fmt_mulhi.f
1976   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1977   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1978
1979   {
1980     DI opval = SRADI (SLLDI (MULDI (EXTSIDI (* FLD (f_r1)), EXTHIDI (TRUNCSIHI (* FLD (f_r2)))), 8), 8);
1981     m32rb_h_accum_set (current_cpu, opval);
1982     TRACE_RESULT (current_cpu, "accum", 'D', opval);
1983   }
1984
1985   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1986
1987 #if WITH_PROFILE_MODEL_P
1988   if (PROFILE_MODEL_P (current_cpu))
1989     {
1990       m32rb_model_mark_get_h_gr (current_cpu, abuf);
1991       m32rb_model_profile_insn (current_cpu, abuf);
1992     }
1993 #endif
1994
1995   return new_pc;
1996 #undef FLD
1997 }
1998
1999 /* mv: mv $dr,$sr.  */
2000
2001 CIA
2002 SEM_FN_NAME (m32rb,mv) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2003 {
2004 #define FLD(f) abuf->fields.fmt_mv.f
2005   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2006   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2007
2008   {
2009     SI opval = * FLD (f_r2);
2010     * FLD (f_r1) = opval;
2011     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2012   }
2013
2014   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2015
2016 #if WITH_PROFILE_MODEL_P
2017   if (PROFILE_MODEL_P (current_cpu))
2018     {
2019       m32rb_model_mark_get_h_gr (current_cpu, abuf);
2020       m32rb_model_mark_set_h_gr (current_cpu, abuf);
2021       m32rb_model_profile_insn (current_cpu, abuf);
2022     }
2023 #endif
2024
2025   return new_pc;
2026 #undef FLD
2027 }
2028
2029 /* mvfachi: mvfachi $dr.  */
2030
2031 CIA
2032 SEM_FN_NAME (m32rb,mvfachi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2033 {
2034 #define FLD(f) abuf->fields.fmt_mvfachi.f
2035   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2036   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2037
2038   {
2039     SI opval = TRUNCDISI (SRADI (m32rb_h_accum_get (current_cpu), 32));
2040     * FLD (f_r1) = opval;
2041     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2042   }
2043
2044   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2045
2046 #if WITH_PROFILE_MODEL_P
2047   if (PROFILE_MODEL_P (current_cpu))
2048     {
2049       m32rb_model_mark_set_h_gr (current_cpu, abuf);
2050       m32rb_model_profile_insn (current_cpu, abuf);
2051     }
2052 #endif
2053
2054   return new_pc;
2055 #undef FLD
2056 }
2057
2058 /* mvfaclo: mvfaclo $dr.  */
2059
2060 CIA
2061 SEM_FN_NAME (m32rb,mvfaclo) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2062 {
2063 #define FLD(f) abuf->fields.fmt_mvfachi.f
2064   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2065   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2066
2067   {
2068     SI opval = TRUNCDISI (m32rb_h_accum_get (current_cpu));
2069     * FLD (f_r1) = opval;
2070     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2071   }
2072
2073   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2074
2075 #if WITH_PROFILE_MODEL_P
2076   if (PROFILE_MODEL_P (current_cpu))
2077     {
2078       m32rb_model_mark_set_h_gr (current_cpu, abuf);
2079       m32rb_model_profile_insn (current_cpu, abuf);
2080     }
2081 #endif
2082
2083   return new_pc;
2084 #undef FLD
2085 }
2086
2087 /* mvfacmi: mvfacmi $dr.  */
2088
2089 CIA
2090 SEM_FN_NAME (m32rb,mvfacmi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2091 {
2092 #define FLD(f) abuf->fields.fmt_mvfachi.f
2093   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2094   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2095
2096   {
2097     SI opval = TRUNCDISI (SRADI (m32rb_h_accum_get (current_cpu), 16));
2098     * FLD (f_r1) = opval;
2099     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2100   }
2101
2102   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2103
2104 #if WITH_PROFILE_MODEL_P
2105   if (PROFILE_MODEL_P (current_cpu))
2106     {
2107       m32rb_model_mark_set_h_gr (current_cpu, abuf);
2108       m32rb_model_profile_insn (current_cpu, abuf);
2109     }
2110 #endif
2111
2112   return new_pc;
2113 #undef FLD
2114 }
2115
2116 /* mvfc: mvfc $dr,$scr.  */
2117
2118 CIA
2119 SEM_FN_NAME (m32rb,mvfc) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2120 {
2121 #define FLD(f) abuf->fields.fmt_mvfc.f
2122   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2123   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2124
2125   {
2126     SI opval = m32rb_h_cr_get (current_cpu, FLD (f_r2));
2127     * FLD (f_r1) = opval;
2128     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2129   }
2130
2131   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2132
2133 #if WITH_PROFILE_MODEL_P
2134   if (PROFILE_MODEL_P (current_cpu))
2135     {
2136       m32rb_model_mark_set_h_gr (current_cpu, abuf);
2137       m32rb_model_profile_insn (current_cpu, abuf);
2138     }
2139 #endif
2140
2141   return new_pc;
2142 #undef FLD
2143 }
2144
2145 /* mvtachi: mvtachi $src1.  */
2146
2147 CIA
2148 SEM_FN_NAME (m32rb,mvtachi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2149 {
2150 #define FLD(f) abuf->fields.fmt_mvtachi.f
2151   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2152   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2153
2154   {
2155     DI opval = ORDI (ANDDI (m32rb_h_accum_get (current_cpu), MAKEDI (0, 0xffffffff)), SLLDI (EXTSIDI (* FLD (f_r1)), 32));
2156     m32rb_h_accum_set (current_cpu, opval);
2157     TRACE_RESULT (current_cpu, "accum", 'D', opval);
2158   }
2159
2160   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2161
2162 #if WITH_PROFILE_MODEL_P
2163   if (PROFILE_MODEL_P (current_cpu))
2164     {
2165       m32rb_model_mark_get_h_gr (current_cpu, abuf);
2166       m32rb_model_profile_insn (current_cpu, abuf);
2167     }
2168 #endif
2169
2170   return new_pc;
2171 #undef FLD
2172 }
2173
2174 /* mvtaclo: mvtaclo $src1.  */
2175
2176 CIA
2177 SEM_FN_NAME (m32rb,mvtaclo) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2178 {
2179 #define FLD(f) abuf->fields.fmt_mvtachi.f
2180   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2181   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2182
2183   {
2184     DI opval = ORDI (ANDDI (m32rb_h_accum_get (current_cpu), MAKEDI (0xffffffff, 0)), ZEXTSIDI (* FLD (f_r1)));
2185     m32rb_h_accum_set (current_cpu, opval);
2186     TRACE_RESULT (current_cpu, "accum", 'D', opval);
2187   }
2188
2189   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2190
2191 #if WITH_PROFILE_MODEL_P
2192   if (PROFILE_MODEL_P (current_cpu))
2193     {
2194       m32rb_model_mark_get_h_gr (current_cpu, abuf);
2195       m32rb_model_profile_insn (current_cpu, abuf);
2196     }
2197 #endif
2198
2199   return new_pc;
2200 #undef FLD
2201 }
2202
2203 /* mvtc: mvtc $sr,$dcr.  */
2204
2205 CIA
2206 SEM_FN_NAME (m32rb,mvtc) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2207 {
2208 #define FLD(f) abuf->fields.fmt_mvtc.f
2209   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2210   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2211
2212   {
2213     USI opval = * FLD (f_r2);
2214     m32rb_h_cr_set (current_cpu, FLD (f_r1), opval);
2215     TRACE_RESULT (current_cpu, "dcr", 'x', opval);
2216   }
2217
2218   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2219
2220 #if WITH_PROFILE_MODEL_P
2221   if (PROFILE_MODEL_P (current_cpu))
2222     {
2223       m32rb_model_mark_get_h_gr (current_cpu, abuf);
2224       m32rb_model_profile_insn (current_cpu, abuf);
2225     }
2226 #endif
2227
2228   return new_pc;
2229 #undef FLD
2230 }
2231
2232 /* neg: neg $dr,$sr.  */
2233
2234 CIA
2235 SEM_FN_NAME (m32rb,neg) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2236 {
2237 #define FLD(f) abuf->fields.fmt_mv.f
2238   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2239   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2240
2241   {
2242     SI opval = NEGSI (* FLD (f_r2));
2243     * FLD (f_r1) = opval;
2244     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2245   }
2246
2247   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2248
2249 #if WITH_PROFILE_MODEL_P
2250   if (PROFILE_MODEL_P (current_cpu))
2251     {
2252       m32rb_model_mark_get_h_gr (current_cpu, abuf);
2253       m32rb_model_mark_set_h_gr (current_cpu, abuf);
2254       m32rb_model_profile_insn (current_cpu, abuf);
2255     }
2256 #endif
2257
2258   return new_pc;
2259 #undef FLD
2260 }
2261
2262 /* nop: nop.  */
2263
2264 CIA
2265 SEM_FN_NAME (m32rb,nop) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2266 {
2267 #define FLD(f) abuf->fields.fmt_nop.f
2268   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2269   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2270
2271 PROFILE_COUNT_FILLNOPS (current_cpu, abuf->addr);
2272
2273   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2274
2275 #if WITH_PROFILE_MODEL_P
2276   if (PROFILE_MODEL_P (current_cpu))
2277     {
2278       m32rb_model_profile_insn (current_cpu, abuf);
2279     }
2280 #endif
2281
2282   return new_pc;
2283 #undef FLD
2284 }
2285
2286 /* not: not $dr,$sr.  */
2287
2288 CIA
2289 SEM_FN_NAME (m32rb,not) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2290 {
2291 #define FLD(f) abuf->fields.fmt_mv.f
2292   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2293   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2294
2295   {
2296     SI opval = INVSI (* FLD (f_r2));
2297     * FLD (f_r1) = opval;
2298     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2299   }
2300
2301   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2302
2303 #if WITH_PROFILE_MODEL_P
2304   if (PROFILE_MODEL_P (current_cpu))
2305     {
2306       m32rb_model_mark_get_h_gr (current_cpu, abuf);
2307       m32rb_model_mark_set_h_gr (current_cpu, abuf);
2308       m32rb_model_profile_insn (current_cpu, abuf);
2309     }
2310 #endif
2311
2312   return new_pc;
2313 #undef FLD
2314 }
2315
2316 /* rac: rac.  */
2317
2318 CIA
2319 SEM_FN_NAME (m32rb,rac) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2320 {
2321 #define FLD(f) abuf->fields.fmt_rac.f
2322   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2323   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2324
2325 do {
2326   DI tmp_tmp1;
2327   tmp_tmp1 = SLLDI (m32rb_h_accum_get (current_cpu), 1);
2328   tmp_tmp1 = ADDDI (tmp_tmp1, MAKEDI (0, 32768));
2329   {
2330     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)));
2331     m32rb_h_accum_set (current_cpu, opval);
2332     TRACE_RESULT (current_cpu, "accum", 'D', opval);
2333   }
2334 } while (0);
2335
2336   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2337
2338 #if WITH_PROFILE_MODEL_P
2339   if (PROFILE_MODEL_P (current_cpu))
2340     {
2341       m32rb_model_profile_insn (current_cpu, abuf);
2342     }
2343 #endif
2344
2345   return new_pc;
2346 #undef FLD
2347 }
2348
2349 /* rach: rach.  */
2350
2351 CIA
2352 SEM_FN_NAME (m32rb,rach) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2353 {
2354 #define FLD(f) abuf->fields.fmt_rac.f
2355   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2356   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2357
2358 do {
2359   DI tmp_tmp1;
2360   tmp_tmp1 = ANDDI (m32rb_h_accum_get (current_cpu), MAKEDI (16777215, 0xffffffff));
2361 if (ANDIF (GEDI (tmp_tmp1, MAKEDI (16383, 0x80000000)), LEDI (tmp_tmp1, MAKEDI (8388607, 0xffffffff)))) {
2362   tmp_tmp1 = MAKEDI (16383, 0x80000000);
2363 } else {
2364 if (ANDIF (GEDI (tmp_tmp1, MAKEDI (8388608, 0)), LEDI (tmp_tmp1, MAKEDI (16760832, 0)))) {
2365   tmp_tmp1 = MAKEDI (16760832, 0);
2366 } else {
2367   tmp_tmp1 = ANDDI (ADDDI (m32rb_h_accum_get (current_cpu), MAKEDI (0, 1073741824)), MAKEDI (0xffffffff, 0x80000000));
2368 }
2369 }
2370   tmp_tmp1 = SLLDI (tmp_tmp1, 1);
2371   {
2372     DI opval = SRADI (SLLDI (tmp_tmp1, 7), 7);
2373     m32rb_h_accum_set (current_cpu, opval);
2374     TRACE_RESULT (current_cpu, "accum", 'D', opval);
2375   }
2376 } while (0);
2377
2378   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2379
2380 #if WITH_PROFILE_MODEL_P
2381   if (PROFILE_MODEL_P (current_cpu))
2382     {
2383       m32rb_model_profile_insn (current_cpu, abuf);
2384     }
2385 #endif
2386
2387   return new_pc;
2388 #undef FLD
2389 }
2390
2391 /* rte: rte.  */
2392
2393 CIA
2394 SEM_FN_NAME (m32rb,rte) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2395 {
2396 #define FLD(f) abuf->fields.fmt_rte.f
2397   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2398   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2399   int taken_p = 0;
2400
2401 do {
2402   {
2403     UBI opval = CPU (h_bsm);
2404     CPU (h_sm) = opval;
2405     TRACE_RESULT (current_cpu, "sm-0", 'x', opval);
2406   }
2407   {
2408     UBI opval = CPU (h_bie);
2409     CPU (h_ie) = opval;
2410     TRACE_RESULT (current_cpu, "ie-0", 'x', opval);
2411   }
2412   {
2413     UBI opval = CPU (h_bcond);
2414     CPU (h_cond) = opval;
2415     TRACE_RESULT (current_cpu, "condbit", 'x', opval);
2416   }
2417   {
2418     USI opval = ANDSI (CPU (h_bpc), -4);
2419     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
2420     taken_p = 1;
2421     TRACE_RESULT (current_cpu, "pc", 'x', opval);
2422   }
2423 } while (0);
2424
2425   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2426
2427 #if WITH_PROFILE_MODEL_P
2428   if (PROFILE_MODEL_P (current_cpu))
2429     {
2430       m32rb_model_profile_cti_insn (current_cpu, abuf, taken_p);
2431     }
2432 #endif
2433
2434   return new_pc;
2435 #undef FLD
2436 }
2437
2438 /* seth: seth $dr,$hash$hi16.  */
2439
2440 CIA
2441 SEM_FN_NAME (m32rb,seth) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2442 {
2443 #define FLD(f) abuf->fields.fmt_seth.f
2444   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2445   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
2446
2447   {
2448     SI opval = SLLSI (FLD (f_hi16), 16);
2449     * FLD (f_r1) = opval;
2450     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2451   }
2452
2453   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2454
2455 #if WITH_PROFILE_MODEL_P
2456   if (PROFILE_MODEL_P (current_cpu))
2457     {
2458       m32rb_model_mark_set_h_gr (current_cpu, abuf);
2459       m32rb_model_profile_insn (current_cpu, abuf);
2460     }
2461 #endif
2462
2463   return new_pc;
2464 #undef FLD
2465 }
2466
2467 /* sll: sll $dr,$sr.  */
2468
2469 CIA
2470 SEM_FN_NAME (m32rb,sll) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2471 {
2472 #define FLD(f) abuf->fields.fmt_add.f
2473   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2474   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2475
2476   {
2477     SI opval = SLLSI (* FLD (f_r1), ANDSI (* FLD (f_r2), 31));
2478     * FLD (f_r1) = opval;
2479     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2480   }
2481
2482   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2483
2484 #if WITH_PROFILE_MODEL_P
2485   if (PROFILE_MODEL_P (current_cpu))
2486     {
2487       m32rb_model_mark_get_h_gr (current_cpu, abuf);
2488       m32rb_model_mark_set_h_gr (current_cpu, abuf);
2489       m32rb_model_profile_insn (current_cpu, abuf);
2490     }
2491 #endif
2492
2493   return new_pc;
2494 #undef FLD
2495 }
2496
2497 /* sll3: sll3 $dr,$sr,$simm16.  */
2498
2499 CIA
2500 SEM_FN_NAME (m32rb,sll3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2501 {
2502 #define FLD(f) abuf->fields.fmt_sll3.f
2503   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2504   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
2505
2506   {
2507     SI opval = SLLSI (* FLD (f_r2), ANDSI (FLD (f_simm16), 31));
2508     * FLD (f_r1) = opval;
2509     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2510   }
2511
2512   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2513
2514 #if WITH_PROFILE_MODEL_P
2515   if (PROFILE_MODEL_P (current_cpu))
2516     {
2517       m32rb_model_mark_get_h_gr (current_cpu, abuf);
2518       m32rb_model_mark_set_h_gr (current_cpu, abuf);
2519       m32rb_model_profile_insn (current_cpu, abuf);
2520     }
2521 #endif
2522
2523   return new_pc;
2524 #undef FLD
2525 }
2526
2527 /* slli: slli $dr,$uimm5.  */
2528
2529 CIA
2530 SEM_FN_NAME (m32rb,slli) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2531 {
2532 #define FLD(f) abuf->fields.fmt_slli.f
2533   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2534   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2535
2536   {
2537     SI opval = SLLSI (* FLD (f_r1), FLD (f_uimm5));
2538     * FLD (f_r1) = opval;
2539     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2540   }
2541
2542   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2543
2544 #if WITH_PROFILE_MODEL_P
2545   if (PROFILE_MODEL_P (current_cpu))
2546     {
2547       m32rb_model_mark_get_h_gr (current_cpu, abuf);
2548       m32rb_model_mark_set_h_gr (current_cpu, abuf);
2549       m32rb_model_profile_insn (current_cpu, abuf);
2550     }
2551 #endif
2552
2553   return new_pc;
2554 #undef FLD
2555 }
2556
2557 /* sra: sra $dr,$sr.  */
2558
2559 CIA
2560 SEM_FN_NAME (m32rb,sra) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2561 {
2562 #define FLD(f) abuf->fields.fmt_add.f
2563   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2564   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2565
2566   {
2567     SI opval = SRASI (* FLD (f_r1), ANDSI (* FLD (f_r2), 31));
2568     * FLD (f_r1) = opval;
2569     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2570   }
2571
2572   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2573
2574 #if WITH_PROFILE_MODEL_P
2575   if (PROFILE_MODEL_P (current_cpu))
2576     {
2577       m32rb_model_mark_get_h_gr (current_cpu, abuf);
2578       m32rb_model_mark_set_h_gr (current_cpu, abuf);
2579       m32rb_model_profile_insn (current_cpu, abuf);
2580     }
2581 #endif
2582
2583   return new_pc;
2584 #undef FLD
2585 }
2586
2587 /* sra3: sra3 $dr,$sr,$simm16.  */
2588
2589 CIA
2590 SEM_FN_NAME (m32rb,sra3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2591 {
2592 #define FLD(f) abuf->fields.fmt_sll3.f
2593   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2594   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
2595
2596   {
2597     SI opval = SRASI (* FLD (f_r2), ANDSI (FLD (f_simm16), 31));
2598     * FLD (f_r1) = opval;
2599     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2600   }
2601
2602   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2603
2604 #if WITH_PROFILE_MODEL_P
2605   if (PROFILE_MODEL_P (current_cpu))
2606     {
2607       m32rb_model_mark_get_h_gr (current_cpu, abuf);
2608       m32rb_model_mark_set_h_gr (current_cpu, abuf);
2609       m32rb_model_profile_insn (current_cpu, abuf);
2610     }
2611 #endif
2612
2613   return new_pc;
2614 #undef FLD
2615 }
2616
2617 /* srai: srai $dr,$uimm5.  */
2618
2619 CIA
2620 SEM_FN_NAME (m32rb,srai) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2621 {
2622 #define FLD(f) abuf->fields.fmt_slli.f
2623   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2624   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2625
2626   {
2627     SI opval = SRASI (* FLD (f_r1), FLD (f_uimm5));
2628     * FLD (f_r1) = opval;
2629     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2630   }
2631
2632   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2633
2634 #if WITH_PROFILE_MODEL_P
2635   if (PROFILE_MODEL_P (current_cpu))
2636     {
2637       m32rb_model_mark_get_h_gr (current_cpu, abuf);
2638       m32rb_model_mark_set_h_gr (current_cpu, abuf);
2639       m32rb_model_profile_insn (current_cpu, abuf);
2640     }
2641 #endif
2642
2643   return new_pc;
2644 #undef FLD
2645 }
2646
2647 /* srl: srl $dr,$sr.  */
2648
2649 CIA
2650 SEM_FN_NAME (m32rb,srl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2651 {
2652 #define FLD(f) abuf->fields.fmt_add.f
2653   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2654   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2655
2656   {
2657     SI opval = SRLSI (* FLD (f_r1), ANDSI (* FLD (f_r2), 31));
2658     * FLD (f_r1) = opval;
2659     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2660   }
2661
2662   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2663
2664 #if WITH_PROFILE_MODEL_P
2665   if (PROFILE_MODEL_P (current_cpu))
2666     {
2667       m32rb_model_mark_get_h_gr (current_cpu, abuf);
2668       m32rb_model_mark_set_h_gr (current_cpu, abuf);
2669       m32rb_model_profile_insn (current_cpu, abuf);
2670     }
2671 #endif
2672
2673   return new_pc;
2674 #undef FLD
2675 }
2676
2677 /* srl3: srl3 $dr,$sr,$simm16.  */
2678
2679 CIA
2680 SEM_FN_NAME (m32rb,srl3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2681 {
2682 #define FLD(f) abuf->fields.fmt_sll3.f
2683   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2684   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
2685
2686   {
2687     SI opval = SRLSI (* FLD (f_r2), ANDSI (FLD (f_simm16), 31));
2688     * FLD (f_r1) = opval;
2689     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2690   }
2691
2692   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2693
2694 #if WITH_PROFILE_MODEL_P
2695   if (PROFILE_MODEL_P (current_cpu))
2696     {
2697       m32rb_model_mark_get_h_gr (current_cpu, abuf);
2698       m32rb_model_mark_set_h_gr (current_cpu, abuf);
2699       m32rb_model_profile_insn (current_cpu, abuf);
2700     }
2701 #endif
2702
2703   return new_pc;
2704 #undef FLD
2705 }
2706
2707 /* srli: srli $dr,$uimm5.  */
2708
2709 CIA
2710 SEM_FN_NAME (m32rb,srli) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2711 {
2712 #define FLD(f) abuf->fields.fmt_slli.f
2713   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2714   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2715
2716   {
2717     SI opval = SRLSI (* FLD (f_r1), FLD (f_uimm5));
2718     * FLD (f_r1) = opval;
2719     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2720   }
2721
2722   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2723
2724 #if WITH_PROFILE_MODEL_P
2725   if (PROFILE_MODEL_P (current_cpu))
2726     {
2727       m32rb_model_mark_get_h_gr (current_cpu, abuf);
2728       m32rb_model_mark_set_h_gr (current_cpu, abuf);
2729       m32rb_model_profile_insn (current_cpu, abuf);
2730     }
2731 #endif
2732
2733   return new_pc;
2734 #undef FLD
2735 }
2736
2737 /* st: st $src1,@$src2.  */
2738
2739 CIA
2740 SEM_FN_NAME (m32rb,st) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2741 {
2742 #define FLD(f) abuf->fields.fmt_st.f
2743   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2744   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2745
2746   {
2747     SI opval = * FLD (f_r1);
2748     SETMEMSI (current_cpu, * FLD (f_r2), opval);
2749     TRACE_RESULT (current_cpu, "memory", 'x', opval);
2750   }
2751
2752   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2753
2754 #if WITH_PROFILE_MODEL_P
2755   if (PROFILE_MODEL_P (current_cpu))
2756     {
2757       m32rb_model_mark_get_h_gr (current_cpu, abuf);
2758       m32rb_model_profile_insn (current_cpu, abuf);
2759     }
2760 #endif
2761
2762   return new_pc;
2763 #undef FLD
2764 }
2765
2766 /* st-d: st $src1,@($slo16,$src2).  */
2767
2768 CIA
2769 SEM_FN_NAME (m32rb,st_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2770 {
2771 #define FLD(f) abuf->fields.fmt_st_d.f
2772   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2773   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
2774
2775   {
2776     SI opval = * FLD (f_r1);
2777     SETMEMSI (current_cpu, ADDSI (* FLD (f_r2), FLD (f_simm16)), opval);
2778     TRACE_RESULT (current_cpu, "memory", 'x', opval);
2779   }
2780
2781   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2782
2783 #if WITH_PROFILE_MODEL_P
2784   if (PROFILE_MODEL_P (current_cpu))
2785     {
2786       m32rb_model_mark_get_h_gr (current_cpu, abuf);
2787       m32rb_model_profile_insn (current_cpu, abuf);
2788     }
2789 #endif
2790
2791   return new_pc;
2792 #undef FLD
2793 }
2794
2795 /* stb: stb $src1,@$src2.  */
2796
2797 CIA
2798 SEM_FN_NAME (m32rb,stb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2799 {
2800 #define FLD(f) abuf->fields.fmt_stb.f
2801   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2802   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2803
2804   {
2805     QI opval = * FLD (f_r1);
2806     SETMEMQI (current_cpu, * FLD (f_r2), opval);
2807     TRACE_RESULT (current_cpu, "memory", 'x', opval);
2808   }
2809
2810   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2811
2812 #if WITH_PROFILE_MODEL_P
2813   if (PROFILE_MODEL_P (current_cpu))
2814     {
2815       m32rb_model_mark_get_h_gr (current_cpu, abuf);
2816       m32rb_model_profile_insn (current_cpu, abuf);
2817     }
2818 #endif
2819
2820   return new_pc;
2821 #undef FLD
2822 }
2823
2824 /* stb-d: stb $src1,@($slo16,$src2).  */
2825
2826 CIA
2827 SEM_FN_NAME (m32rb,stb_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2828 {
2829 #define FLD(f) abuf->fields.fmt_stb_d.f
2830   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2831   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
2832
2833   {
2834     QI opval = * FLD (f_r1);
2835     SETMEMQI (current_cpu, ADDSI (* FLD (f_r2), FLD (f_simm16)), opval);
2836     TRACE_RESULT (current_cpu, "memory", 'x', opval);
2837   }
2838
2839   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2840
2841 #if WITH_PROFILE_MODEL_P
2842   if (PROFILE_MODEL_P (current_cpu))
2843     {
2844       m32rb_model_mark_get_h_gr (current_cpu, abuf);
2845       m32rb_model_profile_insn (current_cpu, abuf);
2846     }
2847 #endif
2848
2849   return new_pc;
2850 #undef FLD
2851 }
2852
2853 /* sth: sth $src1,@$src2.  */
2854
2855 CIA
2856 SEM_FN_NAME (m32rb,sth) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2857 {
2858 #define FLD(f) abuf->fields.fmt_sth.f
2859   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2860   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2861
2862   {
2863     HI opval = * FLD (f_r1);
2864     SETMEMHI (current_cpu, * FLD (f_r2), opval);
2865     TRACE_RESULT (current_cpu, "memory", 'x', opval);
2866   }
2867
2868   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2869
2870 #if WITH_PROFILE_MODEL_P
2871   if (PROFILE_MODEL_P (current_cpu))
2872     {
2873       m32rb_model_mark_get_h_gr (current_cpu, abuf);
2874       m32rb_model_profile_insn (current_cpu, abuf);
2875     }
2876 #endif
2877
2878   return new_pc;
2879 #undef FLD
2880 }
2881
2882 /* sth-d: sth $src1,@($slo16,$src2).  */
2883
2884 CIA
2885 SEM_FN_NAME (m32rb,sth_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2886 {
2887 #define FLD(f) abuf->fields.fmt_sth_d.f
2888   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2889   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
2890
2891   {
2892     HI opval = * FLD (f_r1);
2893     SETMEMHI (current_cpu, ADDSI (* FLD (f_r2), FLD (f_simm16)), opval);
2894     TRACE_RESULT (current_cpu, "memory", 'x', opval);
2895   }
2896
2897   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2898
2899 #if WITH_PROFILE_MODEL_P
2900   if (PROFILE_MODEL_P (current_cpu))
2901     {
2902       m32rb_model_mark_get_h_gr (current_cpu, abuf);
2903       m32rb_model_profile_insn (current_cpu, abuf);
2904     }
2905 #endif
2906
2907   return new_pc;
2908 #undef FLD
2909 }
2910
2911 /* st-plus: st $src1,@+$src2.  */
2912
2913 CIA
2914 SEM_FN_NAME (m32rb,st_plus) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2915 {
2916 #define FLD(f) abuf->fields.fmt_st_plus.f
2917   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2918   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2919
2920 do {
2921   SI tmp_new_src2;
2922   tmp_new_src2 = ADDSI (* FLD (f_r2), 4);
2923   {
2924     SI opval = * FLD (f_r1);
2925     SETMEMSI (current_cpu, tmp_new_src2, opval);
2926     TRACE_RESULT (current_cpu, "memory", 'x', opval);
2927   }
2928   {
2929     SI opval = tmp_new_src2;
2930     * FLD (f_r2) = opval;
2931     TRACE_RESULT (current_cpu, "src2", 'x', opval);
2932   }
2933 } while (0);
2934
2935   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2936
2937 #if WITH_PROFILE_MODEL_P
2938   if (PROFILE_MODEL_P (current_cpu))
2939     {
2940       m32rb_model_mark_get_h_gr (current_cpu, abuf);
2941       m32rb_model_mark_set_h_gr (current_cpu, abuf);
2942       m32rb_model_profile_insn (current_cpu, abuf);
2943     }
2944 #endif
2945
2946   return new_pc;
2947 #undef FLD
2948 }
2949
2950 /* st-minus: st $src1,@-$src2.  */
2951
2952 CIA
2953 SEM_FN_NAME (m32rb,st_minus) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2954 {
2955 #define FLD(f) abuf->fields.fmt_st_plus.f
2956   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2957   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2958
2959 do {
2960   SI tmp_new_src2;
2961   tmp_new_src2 = SUBSI (* FLD (f_r2), 4);
2962   {
2963     SI opval = * FLD (f_r1);
2964     SETMEMSI (current_cpu, tmp_new_src2, opval);
2965     TRACE_RESULT (current_cpu, "memory", 'x', opval);
2966   }
2967   {
2968     SI opval = tmp_new_src2;
2969     * FLD (f_r2) = opval;
2970     TRACE_RESULT (current_cpu, "src2", 'x', opval);
2971   }
2972 } while (0);
2973
2974   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2975
2976 #if WITH_PROFILE_MODEL_P
2977   if (PROFILE_MODEL_P (current_cpu))
2978     {
2979       m32rb_model_mark_get_h_gr (current_cpu, abuf);
2980       m32rb_model_mark_set_h_gr (current_cpu, abuf);
2981       m32rb_model_profile_insn (current_cpu, abuf);
2982     }
2983 #endif
2984
2985   return new_pc;
2986 #undef FLD
2987 }
2988
2989 /* sub: sub $dr,$sr.  */
2990
2991 CIA
2992 SEM_FN_NAME (m32rb,sub) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2993 {
2994 #define FLD(f) abuf->fields.fmt_add.f
2995   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2996   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2997
2998   {
2999     SI opval = SUBSI (* FLD (f_r1), * FLD (f_r2));
3000     * FLD (f_r1) = opval;
3001     TRACE_RESULT (current_cpu, "dr", 'x', opval);
3002   }
3003
3004   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3005
3006 #if WITH_PROFILE_MODEL_P
3007   if (PROFILE_MODEL_P (current_cpu))
3008     {
3009       m32rb_model_mark_get_h_gr (current_cpu, abuf);
3010       m32rb_model_mark_set_h_gr (current_cpu, abuf);
3011       m32rb_model_profile_insn (current_cpu, abuf);
3012     }
3013 #endif
3014
3015   return new_pc;
3016 #undef FLD
3017 }
3018
3019 /* subv: subv $dr,$sr.  */
3020
3021 CIA
3022 SEM_FN_NAME (m32rb,subv) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3023 {
3024 #define FLD(f) abuf->fields.fmt_addv.f
3025   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3026   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
3027
3028 do {
3029   UBI temp1;SI temp0;
3030   temp0 = SUBSI (* FLD (f_r1), * FLD (f_r2));
3031   temp1 = SUBOFSI (* FLD (f_r1), * FLD (f_r2), 0);
3032   {
3033     SI opval = temp0;
3034     * FLD (f_r1) = opval;
3035     TRACE_RESULT (current_cpu, "dr", 'x', opval);
3036   }
3037   {
3038     UBI opval = temp1;
3039     CPU (h_cond) = opval;
3040     TRACE_RESULT (current_cpu, "condbit", 'x', opval);
3041   }
3042 } while (0);
3043
3044   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3045
3046 #if WITH_PROFILE_MODEL_P
3047   if (PROFILE_MODEL_P (current_cpu))
3048     {
3049       m32rb_model_mark_get_h_gr (current_cpu, abuf);
3050       m32rb_model_mark_set_h_gr (current_cpu, abuf);
3051       m32rb_model_profile_insn (current_cpu, abuf);
3052     }
3053 #endif
3054
3055   return new_pc;
3056 #undef FLD
3057 }
3058
3059 /* subx: subx $dr,$sr.  */
3060
3061 CIA
3062 SEM_FN_NAME (m32rb,subx) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3063 {
3064 #define FLD(f) abuf->fields.fmt_addx.f
3065   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3066   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
3067
3068 do {
3069   UBI temp1;SI temp0;
3070   temp0 = SUBCSI (* FLD (f_r1), * FLD (f_r2), CPU (h_cond));
3071   temp1 = SUBCFSI (* FLD (f_r1), * FLD (f_r2), CPU (h_cond));
3072   {
3073     SI opval = temp0;
3074     * FLD (f_r1) = opval;
3075     TRACE_RESULT (current_cpu, "dr", 'x', opval);
3076   }
3077   {
3078     UBI opval = temp1;
3079     CPU (h_cond) = opval;
3080     TRACE_RESULT (current_cpu, "condbit", 'x', opval);
3081   }
3082 } while (0);
3083
3084   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3085
3086 #if WITH_PROFILE_MODEL_P
3087   if (PROFILE_MODEL_P (current_cpu))
3088     {
3089       m32rb_model_mark_get_h_gr (current_cpu, abuf);
3090       m32rb_model_mark_set_h_gr (current_cpu, abuf);
3091       m32rb_model_profile_insn (current_cpu, abuf);
3092     }
3093 #endif
3094
3095   return new_pc;
3096 #undef FLD
3097 }
3098
3099 /* trap: trap $uimm4.  */
3100
3101 CIA
3102 SEM_FN_NAME (m32rb,trap) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3103 {
3104 #define FLD(f) abuf->fields.fmt_trap.f
3105   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3106   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
3107   int taken_p = 0;
3108
3109 do {
3110   {
3111     USI opval = ADDSI (CPU (h_pc), 4);
3112     m32rb_h_cr_set (current_cpu, ((HOSTUINT) 6), opval);
3113     TRACE_RESULT (current_cpu, "cr-6", 'x', opval);
3114   }
3115   {
3116     USI opval = ANDSI (SLLSI (m32rb_h_cr_get (current_cpu, ((HOSTUINT) 0)), 8), 65408);
3117     m32rb_h_cr_set (current_cpu, ((HOSTUINT) 0), opval);
3118     TRACE_RESULT (current_cpu, "cr-0", 'x', opval);
3119   }
3120   {
3121     SI opval = m32r_trap (current_cpu, CPU (h_pc), FLD (f_uimm4));
3122     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
3123     taken_p = 1;
3124     TRACE_RESULT (current_cpu, "pc", 'x', opval);
3125   }
3126 } while (0);
3127
3128   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3129
3130 #if WITH_PROFILE_MODEL_P
3131   if (PROFILE_MODEL_P (current_cpu))
3132     {
3133       m32rb_model_profile_cti_insn (current_cpu, abuf, taken_p);
3134     }
3135 #endif
3136
3137   return new_pc;
3138 #undef FLD
3139 }
3140
3141 /* unlock: unlock $src1,@$src2.  */
3142
3143 CIA
3144 SEM_FN_NAME (m32rb,unlock) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3145 {
3146 #define FLD(f) abuf->fields.fmt_unlock.f
3147   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3148   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
3149
3150 do {
3151 if (CPU (h_lock)) {
3152   {
3153     SI opval = * FLD (f_r1);
3154     SETMEMSI (current_cpu, * FLD (f_r2), opval);
3155     TRACE_RESULT (current_cpu, "memory", 'x', opval);
3156   }
3157 }
3158   {
3159     UBI opval = 0;
3160     CPU (h_lock) = opval;
3161     TRACE_RESULT (current_cpu, "lock-0", 'x', opval);
3162   }
3163 } while (0);
3164
3165   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3166
3167 #if WITH_PROFILE_MODEL_P
3168   if (PROFILE_MODEL_P (current_cpu))
3169     {
3170       m32rb_model_mark_get_h_gr (current_cpu, abuf);
3171       m32rb_model_profile_insn (current_cpu, abuf);
3172     }
3173 #endif
3174
3175   return new_pc;
3176 #undef FLD
3177 }
3178
3179 CIA
3180 SEM_FN_NAME (m32rb,illegal) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3181 {
3182   sim_engine_illegal_insn (current_cpu, NULL_CIA /*FIXME*/);
3183   return 0;
3184 }
3185
3186 #endif /* WANT_CPU */