sim/m32r/semx.c

   1 /* Simulator instruction semantics for m32rx.
   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_M32RX
  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 (m32rx,add) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
  42 {
  43   insn_t insn = SEM_INSN (sem_arg);
  44 #define OPRND(f) par_exec->operands.fmt_add.f
  45   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
  46   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
  47   CIA UNUSED pc = PC;
  48   EXTRACT_FMT_ADD_VARS /* f-op1 f-r1 f-op2 f-r2 */
  49   EXTRACT_FMT_ADD_CODE
  50
  51   {
  52     SI opval = ADDSI (OPRND (dr), OPRND (sr));
  53     CPU (h_gr[f_r1]) = opval;
  54     TRACE_RESULT (current_cpu, "dr", 'x', opval);
  55   }
  56
  57   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
  58
  59 #if WITH_PROFILE_MODEL_P
  60   if (PROFILE_MODEL_P (current_cpu))
  61     {
  62       m32rx_model_mark_get_h_gr (current_cpu, abuf);
  63       m32rx_model_mark_set_h_gr (current_cpu, abuf);
  64       m32rx_model_profile_insn (current_cpu, abuf);
  65     }
  66 #endif
  67
  68   return new_pc;
  69 #undef OPRND
  70 }
  71
  72 /* add3: add3 $dr,$sr,$hash$slo16.  */
  73
  74 CIA
  75 SEM_FN_NAME (m32rx,add3) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
  76 {
  77   insn_t insn = SEM_INSN (sem_arg);
  78 #define OPRND(f) par_exec->operands.fmt_add3.f
  79   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
  80   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
  81   CIA UNUSED pc = PC;
  82   EXTRACT_FMT_ADD3_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
  83   EXTRACT_FMT_ADD3_CODE
  84
  85   {
  86     SI opval = ADDSI (OPRND (sr), OPRND (slo16));
  87     CPU (h_gr[f_r1]) = opval;
  88     TRACE_RESULT (current_cpu, "dr", 'x', opval);
  89   }
  90
  91   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
  92
  93 #if WITH_PROFILE_MODEL_P
  94   if (PROFILE_MODEL_P (current_cpu))
  95     {
  96       m32rx_model_mark_get_h_gr (current_cpu, abuf);
  97       m32rx_model_mark_set_h_gr (current_cpu, abuf);
  98       m32rx_model_profile_insn (current_cpu, abuf);
  99     }
 100 #endif
 101
 102   return new_pc;
 103 #undef OPRND
 104 }
 105
 106 /* and: and $dr,$sr.  */
 107
 108 CIA
 109 SEM_FN_NAME (m32rx,and) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
 110 {
 111   insn_t insn = SEM_INSN (sem_arg);
 112 #define OPRND(f) par_exec->operands.fmt_add.f
 113   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 114   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
 115   CIA UNUSED pc = PC;
 116   EXTRACT_FMT_ADD_VARS /* f-op1 f-r1 f-op2 f-r2 */
 117   EXTRACT_FMT_ADD_CODE
 118
 119   {
 120     SI opval = ANDSI (OPRND (dr), OPRND (sr));
 121     CPU (h_gr[f_r1]) = opval;
 122     TRACE_RESULT (current_cpu, "dr", 'x', opval);
 123   }
 124
 125   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 126
 127 #if WITH_PROFILE_MODEL_P
 128   if (PROFILE_MODEL_P (current_cpu))
 129     {
 130       m32rx_model_mark_get_h_gr (current_cpu, abuf);
 131       m32rx_model_mark_set_h_gr (current_cpu, abuf);
 132       m32rx_model_profile_insn (current_cpu, abuf);
 133     }
 134 #endif
 135
 136   return new_pc;
 137 #undef OPRND
 138 }
 139
 140 /* and3: and3 $dr,$sr,$uimm16.  */
 141
 142 CIA
 143 SEM_FN_NAME (m32rx,and3) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
 144 {
 145   insn_t insn = SEM_INSN (sem_arg);
 146 #define OPRND(f) par_exec->operands.fmt_and3.f
 147   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 148   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 149   CIA UNUSED pc = PC;
 150   EXTRACT_FMT_AND3_VARS /* f-op1 f-r1 f-op2 f-r2 f-uimm16 */
 151   EXTRACT_FMT_AND3_CODE
 152
 153   {
 154     SI opval = ANDSI (OPRND (sr), OPRND (uimm16));
 155     CPU (h_gr[f_r1]) = opval;
 156     TRACE_RESULT (current_cpu, "dr", 'x', opval);
 157   }
 158
 159   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 160
 161 #if WITH_PROFILE_MODEL_P
 162   if (PROFILE_MODEL_P (current_cpu))
 163     {
 164       m32rx_model_mark_get_h_gr (current_cpu, abuf);
 165       m32rx_model_mark_set_h_gr (current_cpu, abuf);
 166       m32rx_model_profile_insn (current_cpu, abuf);
 167     }
 168 #endif
 169
 170   return new_pc;
 171 #undef OPRND
 172 }
 173
 174 /* or: or $dr,$sr.  */
 175
 176 CIA
 177 SEM_FN_NAME (m32rx,or) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
 178 {
 179   insn_t insn = SEM_INSN (sem_arg);
 180 #define OPRND(f) par_exec->operands.fmt_add.f
 181   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 182   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
 183   CIA UNUSED pc = PC;
 184   EXTRACT_FMT_ADD_VARS /* f-op1 f-r1 f-op2 f-r2 */
 185   EXTRACT_FMT_ADD_CODE
 186
 187   {
 188     SI opval = ORSI (OPRND (dr), OPRND (sr));
 189     CPU (h_gr[f_r1]) = opval;
 190     TRACE_RESULT (current_cpu, "dr", 'x', opval);
 191   }
 192
 193   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 194
 195 #if WITH_PROFILE_MODEL_P
 196   if (PROFILE_MODEL_P (current_cpu))
 197     {
 198       m32rx_model_mark_get_h_gr (current_cpu, abuf);
 199       m32rx_model_mark_set_h_gr (current_cpu, abuf);
 200       m32rx_model_profile_insn (current_cpu, abuf);
 201     }
 202 #endif
 203
 204   return new_pc;
 205 #undef OPRND
 206 }
 207
 208 /* or3: or3 $dr,$sr,$hash$ulo16.  */
 209
 210 CIA
 211 SEM_FN_NAME (m32rx,or3) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
 212 {
 213   insn_t insn = SEM_INSN (sem_arg);
 214 #define OPRND(f) par_exec->operands.fmt_or3.f
 215   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 216   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 217   CIA UNUSED pc = PC;
 218   EXTRACT_FMT_OR3_VARS /* f-op1 f-r1 f-op2 f-r2 f-uimm16 */
 219   EXTRACT_FMT_OR3_CODE
 220
 221   {
 222     SI opval = ORSI (OPRND (sr), OPRND (ulo16));
 223     CPU (h_gr[f_r1]) = opval;
 224     TRACE_RESULT (current_cpu, "dr", 'x', opval);
 225   }
 226
 227   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 228
 229 #if WITH_PROFILE_MODEL_P
 230   if (PROFILE_MODEL_P (current_cpu))
 231     {
 232       m32rx_model_mark_get_h_gr (current_cpu, abuf);
 233       m32rx_model_mark_set_h_gr (current_cpu, abuf);
 234       m32rx_model_profile_insn (current_cpu, abuf);
 235     }
 236 #endif
 237
 238   return new_pc;
 239 #undef OPRND
 240 }
 241
 242 /* xor: xor $dr,$sr.  */
 243
 244 CIA
 245 SEM_FN_NAME (m32rx,xor) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
 246 {
 247   insn_t insn = SEM_INSN (sem_arg);
 248 #define OPRND(f) par_exec->operands.fmt_add.f
 249   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 250   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
 251   CIA UNUSED pc = PC;
 252   EXTRACT_FMT_ADD_VARS /* f-op1 f-r1 f-op2 f-r2 */
 253   EXTRACT_FMT_ADD_CODE
 254
 255   {
 256     SI opval = XORSI (OPRND (dr), OPRND (sr));
 257     CPU (h_gr[f_r1]) = opval;
 258     TRACE_RESULT (current_cpu, "dr", 'x', opval);
 259   }
 260
 261   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 262
 263 #if WITH_PROFILE_MODEL_P
 264   if (PROFILE_MODEL_P (current_cpu))
 265     {
 266       m32rx_model_mark_get_h_gr (current_cpu, abuf);
 267       m32rx_model_mark_set_h_gr (current_cpu, abuf);
 268       m32rx_model_profile_insn (current_cpu, abuf);
 269     }
 270 #endif
 271
 272   return new_pc;
 273 #undef OPRND
 274 }
 275
 276 /* xor3: xor3 $dr,$sr,$uimm16.  */
 277
 278 CIA
 279 SEM_FN_NAME (m32rx,xor3) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
 280 {
 281   insn_t insn = SEM_INSN (sem_arg);
 282 #define OPRND(f) par_exec->operands.fmt_and3.f
 283   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 284   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 285   CIA UNUSED pc = PC;
 286   EXTRACT_FMT_AND3_VARS /* f-op1 f-r1 f-op2 f-r2 f-uimm16 */
 287   EXTRACT_FMT_AND3_CODE
 288
 289   {
 290     SI opval = XORSI (OPRND (sr), OPRND (uimm16));
 291     CPU (h_gr[f_r1]) = opval;
 292     TRACE_RESULT (current_cpu, "dr", 'x', opval);
 293   }
 294
 295   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 296
 297 #if WITH_PROFILE_MODEL_P
 298   if (PROFILE_MODEL_P (current_cpu))
 299     {
 300       m32rx_model_mark_get_h_gr (current_cpu, abuf);
 301       m32rx_model_mark_set_h_gr (current_cpu, abuf);
 302       m32rx_model_profile_insn (current_cpu, abuf);
 303     }
 304 #endif
 305
 306   return new_pc;
 307 #undef OPRND
 308 }
 309
 310 /* addi: addi $dr,$simm8.  */
 311
 312 CIA
 313 SEM_FN_NAME (m32rx,addi) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
 314 {
 315   insn_t insn = SEM_INSN (sem_arg);
 316 #define OPRND(f) par_exec->operands.fmt_addi.f
 317   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 318   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
 319   CIA UNUSED pc = PC;
 320   EXTRACT_FMT_ADDI_VARS /* f-op1 f-r1 f-simm8 */
 321   EXTRACT_FMT_ADDI_CODE
 322
 323   {
 324     SI opval = ADDSI (OPRND (dr), OPRND (simm8));
 325     CPU (h_gr[f_r1]) = opval;
 326     TRACE_RESULT (current_cpu, "dr", 'x', opval);
 327   }
 328
 329   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 330
 331 #if WITH_PROFILE_MODEL_P
 332   if (PROFILE_MODEL_P (current_cpu))
 333     {
 334       m32rx_model_mark_get_h_gr (current_cpu, abuf);
 335       m32rx_model_mark_set_h_gr (current_cpu, abuf);
 336       m32rx_model_profile_insn (current_cpu, abuf);
 337     }
 338 #endif
 339
 340   return new_pc;
 341 #undef OPRND
 342 }
 343
 344 /* addv: addv $dr,$sr.  */
 345
 346 CIA
 347 SEM_FN_NAME (m32rx,addv) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
 348 {
 349   insn_t insn = SEM_INSN (sem_arg);
 350 #define OPRND(f) par_exec->operands.fmt_addv.f
 351   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 352   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
 353   CIA UNUSED pc = PC;
 354   EXTRACT_FMT_ADDV_VARS /* f-op1 f-r1 f-op2 f-r2 */
 355   EXTRACT_FMT_ADDV_CODE
 356
 357 do {
 358   UBI temp1;SI temp0;
 359   temp0 = ADDSI (OPRND (dr), OPRND (sr));
 360   temp1 = ADDOFSI (OPRND (dr), OPRND (sr), 0);
 361   {
 362     SI opval = temp0;
 363     CPU (h_gr[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       m32rx_model_mark_get_h_gr (current_cpu, abuf);
 379       m32rx_model_mark_set_h_gr (current_cpu, abuf);
 380       m32rx_model_profile_insn (current_cpu, abuf);
 381     }
 382 #endif
 383
 384   return new_pc;
 385 #undef OPRND
 386 }
 387
 388 /* addv3: addv3 $dr,$sr,$simm16.  */
 389
 390 CIA
 391 SEM_FN_NAME (m32rx,addv3) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
 392 {
 393   insn_t insn = SEM_INSN (sem_arg);
 394 #define OPRND(f) par_exec->operands.fmt_addv3.f
 395   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 396   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 397   CIA UNUSED pc = PC;
 398   EXTRACT_FMT_ADDV3_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
 399   EXTRACT_FMT_ADDV3_CODE
 400
 401 do {
 402   UBI temp1;SI temp0;
 403   temp0 = ADDSI (OPRND (sr), OPRND (simm16));
 404   temp1 = ADDOFSI (OPRND (sr), OPRND (simm16), 0);
 405   {
 406     SI opval = temp0;
 407     CPU (h_gr[f_r1]) = opval;
 408     TRACE_RESULT (current_cpu, "dr", 'x', opval);
 409   }
 410   {
 411     UBI opval = temp1;
 412     CPU (h_cond) = opval;
 413     TRACE_RESULT (current_cpu, "condbit", 'x', opval);
 414   }
 415 } while (0);
 416
 417   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 418
 419 #if WITH_PROFILE_MODEL_P
 420   if (PROFILE_MODEL_P (current_cpu))
 421     {
 422       m32rx_model_mark_get_h_gr (current_cpu, abuf);
 423       m32rx_model_mark_set_h_gr (current_cpu, abuf);
 424       m32rx_model_profile_insn (current_cpu, abuf);
 425     }
 426 #endif
 427
 428   return new_pc;
 429 #undef OPRND
 430 }
 431
 432 /* addx: addx $dr,$sr.  */
 433
 434 CIA
 435 SEM_FN_NAME (m32rx,addx) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
 436 {
 437   insn_t insn = SEM_INSN (sem_arg);
 438 #define OPRND(f) par_exec->operands.fmt_addx.f
 439   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 440   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
 441   CIA UNUSED pc = PC;
 442   EXTRACT_FMT_ADDX_VARS /* f-op1 f-r1 f-op2 f-r2 */
 443   EXTRACT_FMT_ADDX_CODE
 444
 445 do {
 446   UBI temp1;SI temp0;
 447   temp0 = ADDCSI (OPRND (dr), OPRND (sr), OPRND (condbit));
 448   temp1 = ADDCFSI (OPRND (dr), OPRND (sr), OPRND (condbit));
 449   {
 450     SI opval = temp0;
 451     CPU (h_gr[f_r1]) = opval;
 452     TRACE_RESULT (current_cpu, "dr", 'x', opval);
 453   }
 454   {
 455     UBI opval = temp1;
 456     CPU (h_cond) = opval;
 457     TRACE_RESULT (current_cpu, "condbit", 'x', opval);
 458   }
 459 } while (0);
 460
 461   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 462
 463 #if WITH_PROFILE_MODEL_P
 464   if (PROFILE_MODEL_P (current_cpu))
 465     {
 466       m32rx_model_mark_get_h_gr (current_cpu, abuf);
 467       m32rx_model_mark_set_h_gr (current_cpu, abuf);
 468       m32rx_model_profile_insn (current_cpu, abuf);
 469     }
 470 #endif
 471
 472   return new_pc;
 473 #undef OPRND
 474 }
 475
 476 /* bc8: bc.s $disp8.  */
 477
 478 CIA
 479 SEM_FN_NAME (m32rx,bc8) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
 480 {
 481   insn_t insn = SEM_INSN (sem_arg);
 482 #define OPRND(f) par_exec->operands.fmt_bc8.f
 483   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 484   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
 485   int taken_p = 0;
 486   CIA UNUSED pc = PC;
 487   EXTRACT_FMT_BC8_VARS /* f-op1 f-r1 f-disp8 */
 488   EXTRACT_FMT_BC8_CODE
 489
 490 if (OPRND (condbit)) {
 491   {
 492     USI opval = OPRND (disp8);
 493     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
 494     taken_p = 1;
 495     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 496   }
 497 }
 498
 499   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 500
 501 #if WITH_PROFILE_MODEL_P
 502   if (PROFILE_MODEL_P (current_cpu))
 503     {
 504       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
 505     }
 506 #endif
 507
 508   return new_pc;
 509 #undef OPRND
 510 }
 511
 512 /* bc24: bc.l $disp24.  */
 513
 514 CIA
 515 SEM_FN_NAME (m32rx,bc24) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
 516 {
 517   insn_t insn = SEM_INSN (sem_arg);
 518 #define OPRND(f) par_exec->operands.fmt_bc24.f
 519   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 520   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 521   int taken_p = 0;
 522   CIA UNUSED pc = PC;
 523   EXTRACT_FMT_BC24_VARS /* f-op1 f-r1 f-disp24 */
 524   EXTRACT_FMT_BC24_CODE
 525
 526 if (OPRND (condbit)) {
 527   {
 528     USI opval = OPRND (disp24);
 529     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
 530     taken_p = 1;
 531     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 532   }
 533 }
 534
 535   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 536
 537 #if WITH_PROFILE_MODEL_P
 538   if (PROFILE_MODEL_P (current_cpu))
 539     {
 540       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
 541     }
 542 #endif
 543
 544   return new_pc;
 545 #undef OPRND
 546 }
 547
 548 /* beq: beq $src1,$src2,$disp16.  */
 549
 550 CIA
 551 SEM_FN_NAME (m32rx,beq) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
 552 {
 553   insn_t insn = SEM_INSN (sem_arg);
 554 #define OPRND(f) par_exec->operands.fmt_beq.f
 555   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 556   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 557   int taken_p = 0;
 558   CIA UNUSED pc = PC;
 559   EXTRACT_FMT_BEQ_VARS /* f-op1 f-r1 f-op2 f-r2 f-disp16 */
 560   EXTRACT_FMT_BEQ_CODE
 561
 562 if (EQSI (OPRND (src1), OPRND (src2))) {
 563   {
 564     USI opval = OPRND (disp16);
 565     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
 566     taken_p = 1;
 567     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 568   }
 569 }
 570
 571   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 572
 573 #if WITH_PROFILE_MODEL_P
 574   if (PROFILE_MODEL_P (current_cpu))
 575     {
 576       m32rx_model_mark_get_h_gr (current_cpu, abuf);
 577       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
 578     }
 579 #endif
 580
 581   return new_pc;
 582 #undef OPRND
 583 }
 584
 585 /* beqz: beqz $src2,$disp16.  */
 586
 587 CIA
 588 SEM_FN_NAME (m32rx,beqz) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
 589 {
 590   insn_t insn = SEM_INSN (sem_arg);
 591 #define OPRND(f) par_exec->operands.fmt_beqz.f
 592   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 593   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 594   int taken_p = 0;
 595   CIA UNUSED pc = PC;
 596   EXTRACT_FMT_BEQZ_VARS /* f-op1 f-r1 f-op2 f-r2 f-disp16 */
 597   EXTRACT_FMT_BEQZ_CODE
 598
 599 if (EQSI (OPRND (src2), 0)) {
 600   {
 601     USI opval = OPRND (disp16);
 602     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
 603     taken_p = 1;
 604     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 605   }
 606 }
 607
 608   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 609
 610 #if WITH_PROFILE_MODEL_P
 611   if (PROFILE_MODEL_P (current_cpu))
 612     {
 613       m32rx_model_mark_get_h_gr (current_cpu, abuf);
 614       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
 615     }
 616 #endif
 617
 618   return new_pc;
 619 #undef OPRND
 620 }
 621
 622 /* bgez: bgez $src2,$disp16.  */
 623
 624 CIA
 625 SEM_FN_NAME (m32rx,bgez) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
 626 {
 627   insn_t insn = SEM_INSN (sem_arg);
 628 #define OPRND(f) par_exec->operands.fmt_beqz.f
 629   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 630   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 631   int taken_p = 0;
 632   CIA UNUSED pc = PC;
 633   EXTRACT_FMT_BEQZ_VARS /* f-op1 f-r1 f-op2 f-r2 f-disp16 */
 634   EXTRACT_FMT_BEQZ_CODE
 635
 636 if (GESI (OPRND (src2), 0)) {
 637   {
 638     USI opval = OPRND (disp16);
 639     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
 640     taken_p = 1;
 641     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 642   }
 643 }
 644
 645   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 646
 647 #if WITH_PROFILE_MODEL_P
 648   if (PROFILE_MODEL_P (current_cpu))
 649     {
 650       m32rx_model_mark_get_h_gr (current_cpu, abuf);
 651       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
 652     }
 653 #endif
 654
 655   return new_pc;
 656 #undef OPRND
 657 }
 658
 659 /* bgtz: bgtz $src2,$disp16.  */
 660
 661 CIA
 662 SEM_FN_NAME (m32rx,bgtz) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
 663 {
 664   insn_t insn = SEM_INSN (sem_arg);
 665 #define OPRND(f) par_exec->operands.fmt_beqz.f
 666   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 667   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 668   int taken_p = 0;
 669   CIA UNUSED pc = PC;
 670   EXTRACT_FMT_BEQZ_VARS /* f-op1 f-r1 f-op2 f-r2 f-disp16 */
 671   EXTRACT_FMT_BEQZ_CODE
 672
 673 if (GTSI (OPRND (src2), 0)) {
 674   {
 675     USI opval = OPRND (disp16);
 676     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
 677     taken_p = 1;
 678     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 679   }
 680 }
 681
 682   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 683
 684 #if WITH_PROFILE_MODEL_P
 685   if (PROFILE_MODEL_P (current_cpu))
 686     {
 687       m32rx_model_mark_get_h_gr (current_cpu, abuf);
 688       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
 689     }
 690 #endif
 691
 692   return new_pc;
 693 #undef OPRND
 694 }
 695
 696 /* blez: blez $src2,$disp16.  */
 697
 698 CIA
 699 SEM_FN_NAME (m32rx,blez) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
 700 {
 701   insn_t insn = SEM_INSN (sem_arg);
 702 #define OPRND(f) par_exec->operands.fmt_beqz.f
 703   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 704   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 705   int taken_p = 0;
 706   CIA UNUSED pc = PC;
 707   EXTRACT_FMT_BEQZ_VARS /* f-op1 f-r1 f-op2 f-r2 f-disp16 */
 708   EXTRACT_FMT_BEQZ_CODE
 709
 710 if (LESI (OPRND (src2), 0)) {
 711   {
 712     USI opval = OPRND (disp16);
 713     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
 714     taken_p = 1;
 715     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 716   }
 717 }
 718
 719   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 720
 721 #if WITH_PROFILE_MODEL_P
 722   if (PROFILE_MODEL_P (current_cpu))
 723     {
 724       m32rx_model_mark_get_h_gr (current_cpu, abuf);
 725       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
 726     }
 727 #endif
 728
 729   return new_pc;
 730 #undef OPRND
 731 }
 732
 733 /* bltz: bltz $src2,$disp16.  */
 734
 735 CIA
 736 SEM_FN_NAME (m32rx,bltz) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
 737 {
 738   insn_t insn = SEM_INSN (sem_arg);
 739 #define OPRND(f) par_exec->operands.fmt_beqz.f
 740   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 741   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 742   int taken_p = 0;
 743   CIA UNUSED pc = PC;
 744   EXTRACT_FMT_BEQZ_VARS /* f-op1 f-r1 f-op2 f-r2 f-disp16 */
 745   EXTRACT_FMT_BEQZ_CODE
 746
 747 if (LTSI (OPRND (src2), 0)) {
 748   {
 749     USI opval = OPRND (disp16);
 750     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
 751     taken_p = 1;
 752     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 753   }
 754 }
 755
 756   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 757
 758 #if WITH_PROFILE_MODEL_P
 759   if (PROFILE_MODEL_P (current_cpu))
 760     {
 761       m32rx_model_mark_get_h_gr (current_cpu, abuf);
 762       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
 763     }
 764 #endif
 765
 766   return new_pc;
 767 #undef OPRND
 768 }
 769
 770 /* bnez: bnez $src2,$disp16.  */
 771
 772 CIA
 773 SEM_FN_NAME (m32rx,bnez) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
 774 {
 775   insn_t insn = SEM_INSN (sem_arg);
 776 #define OPRND(f) par_exec->operands.fmt_beqz.f
 777   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 778   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 779   int taken_p = 0;
 780   CIA UNUSED pc = PC;
 781   EXTRACT_FMT_BEQZ_VARS /* f-op1 f-r1 f-op2 f-r2 f-disp16 */
 782   EXTRACT_FMT_BEQZ_CODE
 783
 784 if (NESI (OPRND (src2), 0)) {
 785   {
 786     USI opval = OPRND (disp16);
 787     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
 788     taken_p = 1;
 789     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 790   }
 791 }
 792
 793   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 794
 795 #if WITH_PROFILE_MODEL_P
 796   if (PROFILE_MODEL_P (current_cpu))
 797     {
 798       m32rx_model_mark_get_h_gr (current_cpu, abuf);
 799       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
 800     }
 801 #endif
 802
 803   return new_pc;
 804 #undef OPRND
 805 }
 806
 807 /* bl8: bl.s $disp8.  */
 808
 809 CIA
 810 SEM_FN_NAME (m32rx,bl8) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
 811 {
 812   insn_t insn = SEM_INSN (sem_arg);
 813 #define OPRND(f) par_exec->operands.fmt_bl8.f
 814   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 815   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
 816   int taken_p = 0;
 817   CIA UNUSED pc = PC;
 818   EXTRACT_FMT_BL8_VARS /* f-op1 f-r1 f-disp8 */
 819   EXTRACT_FMT_BL8_CODE
 820
 821 do {
 822   {
 823     SI opval = ADDSI (ANDSI (OPRND (pc), -4), 4);
 824     CPU (h_gr[((HOSTUINT) 14)]) = opval;
 825     TRACE_RESULT (current_cpu, "gr-14", 'x', opval);
 826   }
 827   {
 828     USI opval = OPRND (disp8);
 829     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
 830     taken_p = 1;
 831     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 832   }
 833 } while (0);
 834
 835   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 836
 837 #if WITH_PROFILE_MODEL_P
 838   if (PROFILE_MODEL_P (current_cpu))
 839     {
 840       m32rx_model_mark_set_h_gr (current_cpu, abuf);
 841       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
 842     }
 843 #endif
 844
 845   return new_pc;
 846 #undef OPRND
 847 }
 848
 849 /* bl24: bl.l $disp24.  */
 850
 851 CIA
 852 SEM_FN_NAME (m32rx,bl24) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
 853 {
 854   insn_t insn = SEM_INSN (sem_arg);
 855 #define OPRND(f) par_exec->operands.fmt_bl24.f
 856   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 857   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 858   int taken_p = 0;
 859   CIA UNUSED pc = PC;
 860   EXTRACT_FMT_BL24_VARS /* f-op1 f-r1 f-disp24 */
 861   EXTRACT_FMT_BL24_CODE
 862
 863 do {
 864   {
 865     SI opval = ADDSI (OPRND (pc), 4);
 866     CPU (h_gr[((HOSTUINT) 14)]) = opval;
 867     TRACE_RESULT (current_cpu, "gr-14", 'x', opval);
 868   }
 869   {
 870     USI opval = OPRND (disp24);
 871     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
 872     taken_p = 1;
 873     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 874   }
 875 } while (0);
 876
 877   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 878
 879 #if WITH_PROFILE_MODEL_P
 880   if (PROFILE_MODEL_P (current_cpu))
 881     {
 882       m32rx_model_mark_set_h_gr (current_cpu, abuf);
 883       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
 884     }
 885 #endif
 886
 887   return new_pc;
 888 #undef OPRND
 889 }
 890
 891 /* bcl8: bcl.s $disp8.  */
 892
 893 CIA
 894 SEM_FN_NAME (m32rx,bcl8) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
 895 {
 896   insn_t insn = SEM_INSN (sem_arg);
 897 #define OPRND(f) par_exec->operands.fmt_bcl8.f
 898   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 899   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
 900   int taken_p = 0;
 901   CIA UNUSED pc = PC;
 902   EXTRACT_FMT_BCL8_VARS /* f-op1 f-r1 f-disp8 */
 903   EXTRACT_FMT_BCL8_CODE
 904
 905 if (OPRND (condbit)) {
 906 do {
 907   {
 908     SI opval = ADDSI (ANDSI (OPRND (pc), -4), 4);
 909     CPU (h_gr[((HOSTUINT) 14)]) = opval;
 910     TRACE_RESULT (current_cpu, "gr-14", 'x', opval);
 911   }
 912   {
 913     USI opval = OPRND (disp8);
 914     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
 915     taken_p = 1;
 916     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 917   }
 918 } while (0);
 919 }
 920
 921   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 922
 923 #if WITH_PROFILE_MODEL_P
 924   if (PROFILE_MODEL_P (current_cpu))
 925     {
 926       m32rx_model_mark_set_h_gr (current_cpu, abuf);
 927       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
 928     }
 929 #endif
 930
 931   return new_pc;
 932 #undef OPRND
 933 }
 934
 935 /* bcl24: bcl.l $disp24.  */
 936
 937 CIA
 938 SEM_FN_NAME (m32rx,bcl24) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
 939 {
 940   insn_t insn = SEM_INSN (sem_arg);
 941 #define OPRND(f) par_exec->operands.fmt_bcl24.f
 942   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 943   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
 944   int taken_p = 0;
 945   CIA UNUSED pc = PC;
 946   EXTRACT_FMT_BCL24_VARS /* f-op1 f-r1 f-disp24 */
 947   EXTRACT_FMT_BCL24_CODE
 948
 949 if (OPRND (condbit)) {
 950 do {
 951   {
 952     SI opval = ADDSI (OPRND (pc), 4);
 953     CPU (h_gr[((HOSTUINT) 14)]) = opval;
 954     TRACE_RESULT (current_cpu, "gr-14", 'x', opval);
 955   }
 956   {
 957     USI opval = OPRND (disp24);
 958     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
 959     taken_p = 1;
 960     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 961   }
 962 } while (0);
 963 }
 964
 965   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
 966
 967 #if WITH_PROFILE_MODEL_P
 968   if (PROFILE_MODEL_P (current_cpu))
 969     {
 970       m32rx_model_mark_set_h_gr (current_cpu, abuf);
 971       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
 972     }
 973 #endif
 974
 975   return new_pc;
 976 #undef OPRND
 977 }
 978
 979 /* bnc8: bnc.s $disp8.  */
 980
 981 CIA
 982 SEM_FN_NAME (m32rx,bnc8) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
 983 {
 984   insn_t insn = SEM_INSN (sem_arg);
 985 #define OPRND(f) par_exec->operands.fmt_bc8.f
 986   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 987   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
 988   int taken_p = 0;
 989   CIA UNUSED pc = PC;
 990   EXTRACT_FMT_BC8_VARS /* f-op1 f-r1 f-disp8 */
 991   EXTRACT_FMT_BC8_CODE
 992
 993 if (NOTBI (OPRND (condbit))) {
 994   {
 995     USI opval = OPRND (disp8);
 996     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
 997     taken_p = 1;
 998     TRACE_RESULT (current_cpu, "pc", 'x', opval);
 999   }
1000 }
1001
1002   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1003
1004 #if WITH_PROFILE_MODEL_P
1005   if (PROFILE_MODEL_P (current_cpu))
1006     {
1007       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
1008     }
1009 #endif
1010
1011   return new_pc;
1012 #undef OPRND
1013 }
1014
1015 /* bnc24: bnc.l $disp24.  */
1016
1017 CIA
1018 SEM_FN_NAME (m32rx,bnc24) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1019 {
1020   insn_t insn = SEM_INSN (sem_arg);
1021 #define OPRND(f) par_exec->operands.fmt_bc24.f
1022   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1023   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1024   int taken_p = 0;
1025   CIA UNUSED pc = PC;
1026   EXTRACT_FMT_BC24_VARS /* f-op1 f-r1 f-disp24 */
1027   EXTRACT_FMT_BC24_CODE
1028
1029 if (NOTBI (OPRND (condbit))) {
1030   {
1031     USI opval = OPRND (disp24);
1032     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
1033     taken_p = 1;
1034     TRACE_RESULT (current_cpu, "pc", 'x', opval);
1035   }
1036 }
1037
1038   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1039
1040 #if WITH_PROFILE_MODEL_P
1041   if (PROFILE_MODEL_P (current_cpu))
1042     {
1043       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
1044     }
1045 #endif
1046
1047   return new_pc;
1048 #undef OPRND
1049 }
1050
1051 /* bne: bne $src1,$src2,$disp16.  */
1052
1053 CIA
1054 SEM_FN_NAME (m32rx,bne) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1055 {
1056   insn_t insn = SEM_INSN (sem_arg);
1057 #define OPRND(f) par_exec->operands.fmt_beq.f
1058   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1059   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1060   int taken_p = 0;
1061   CIA UNUSED pc = PC;
1062   EXTRACT_FMT_BEQ_VARS /* f-op1 f-r1 f-op2 f-r2 f-disp16 */
1063   EXTRACT_FMT_BEQ_CODE
1064
1065 if (NESI (OPRND (src1), OPRND (src2))) {
1066   {
1067     USI opval = OPRND (disp16);
1068     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
1069     taken_p = 1;
1070     TRACE_RESULT (current_cpu, "pc", 'x', opval);
1071   }
1072 }
1073
1074   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1075
1076 #if WITH_PROFILE_MODEL_P
1077   if (PROFILE_MODEL_P (current_cpu))
1078     {
1079       m32rx_model_mark_get_h_gr (current_cpu, abuf);
1080       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
1081     }
1082 #endif
1083
1084   return new_pc;
1085 #undef OPRND
1086 }
1087
1088 /* bra8: bra.s $disp8.  */
1089
1090 CIA
1091 SEM_FN_NAME (m32rx,bra8) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1092 {
1093   insn_t insn = SEM_INSN (sem_arg);
1094 #define OPRND(f) par_exec->operands.fmt_bra8.f
1095   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1096   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1097   int taken_p = 0;
1098   CIA UNUSED pc = PC;
1099   EXTRACT_FMT_BRA8_VARS /* f-op1 f-r1 f-disp8 */
1100   EXTRACT_FMT_BRA8_CODE
1101
1102   {
1103     USI opval = OPRND (disp8);
1104     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
1105     taken_p = 1;
1106     TRACE_RESULT (current_cpu, "pc", 'x', opval);
1107   }
1108
1109   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1110
1111 #if WITH_PROFILE_MODEL_P
1112   if (PROFILE_MODEL_P (current_cpu))
1113     {
1114       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
1115     }
1116 #endif
1117
1118   return new_pc;
1119 #undef OPRND
1120 }
1121
1122 /* bra24: bra.l $disp24.  */
1123
1124 CIA
1125 SEM_FN_NAME (m32rx,bra24) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1126 {
1127   insn_t insn = SEM_INSN (sem_arg);
1128 #define OPRND(f) par_exec->operands.fmt_bra24.f
1129   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1130   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1131   int taken_p = 0;
1132   CIA UNUSED pc = PC;
1133   EXTRACT_FMT_BRA24_VARS /* f-op1 f-r1 f-disp24 */
1134   EXTRACT_FMT_BRA24_CODE
1135
1136   {
1137     USI opval = OPRND (disp24);
1138     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
1139     taken_p = 1;
1140     TRACE_RESULT (current_cpu, "pc", 'x', opval);
1141   }
1142
1143   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1144
1145 #if WITH_PROFILE_MODEL_P
1146   if (PROFILE_MODEL_P (current_cpu))
1147     {
1148       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
1149     }
1150 #endif
1151
1152   return new_pc;
1153 #undef OPRND
1154 }
1155
1156 /* bncl8: bncl.s $disp8.  */
1157
1158 CIA
1159 SEM_FN_NAME (m32rx,bncl8) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1160 {
1161   insn_t insn = SEM_INSN (sem_arg);
1162 #define OPRND(f) par_exec->operands.fmt_bcl8.f
1163   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1164   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1165   int taken_p = 0;
1166   CIA UNUSED pc = PC;
1167   EXTRACT_FMT_BCL8_VARS /* f-op1 f-r1 f-disp8 */
1168   EXTRACT_FMT_BCL8_CODE
1169
1170 if (NOTBI (OPRND (condbit))) {
1171 do {
1172   {
1173     SI opval = ADDSI (ANDSI (OPRND (pc), -4), 4);
1174     CPU (h_gr[((HOSTUINT) 14)]) = opval;
1175     TRACE_RESULT (current_cpu, "gr-14", 'x', opval);
1176   }
1177   {
1178     USI opval = OPRND (disp8);
1179     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
1180     taken_p = 1;
1181     TRACE_RESULT (current_cpu, "pc", 'x', opval);
1182   }
1183 } while (0);
1184 }
1185
1186   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1187
1188 #if WITH_PROFILE_MODEL_P
1189   if (PROFILE_MODEL_P (current_cpu))
1190     {
1191       m32rx_model_mark_set_h_gr (current_cpu, abuf);
1192       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
1193     }
1194 #endif
1195
1196   return new_pc;
1197 #undef OPRND
1198 }
1199
1200 /* bncl24: bncl.l $disp24.  */
1201
1202 CIA
1203 SEM_FN_NAME (m32rx,bncl24) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1204 {
1205   insn_t insn = SEM_INSN (sem_arg);
1206 #define OPRND(f) par_exec->operands.fmt_bcl24.f
1207   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1208   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1209   int taken_p = 0;
1210   CIA UNUSED pc = PC;
1211   EXTRACT_FMT_BCL24_VARS /* f-op1 f-r1 f-disp24 */
1212   EXTRACT_FMT_BCL24_CODE
1213
1214 if (NOTBI (OPRND (condbit))) {
1215 do {
1216   {
1217     SI opval = ADDSI (OPRND (pc), 4);
1218     CPU (h_gr[((HOSTUINT) 14)]) = opval;
1219     TRACE_RESULT (current_cpu, "gr-14", 'x', opval);
1220   }
1221   {
1222     USI opval = OPRND (disp24);
1223     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
1224     taken_p = 1;
1225     TRACE_RESULT (current_cpu, "pc", 'x', opval);
1226   }
1227 } while (0);
1228 }
1229
1230   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1231
1232 #if WITH_PROFILE_MODEL_P
1233   if (PROFILE_MODEL_P (current_cpu))
1234     {
1235       m32rx_model_mark_set_h_gr (current_cpu, abuf);
1236       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
1237     }
1238 #endif
1239
1240   return new_pc;
1241 #undef OPRND
1242 }
1243
1244 /* cmp: cmp $src1,$src2.  */
1245
1246 CIA
1247 SEM_FN_NAME (m32rx,cmp) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1248 {
1249   insn_t insn = SEM_INSN (sem_arg);
1250 #define OPRND(f) par_exec->operands.fmt_cmp.f
1251   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1252   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1253   CIA UNUSED pc = PC;
1254   EXTRACT_FMT_CMP_VARS /* f-op1 f-r1 f-op2 f-r2 */
1255   EXTRACT_FMT_CMP_CODE
1256
1257   {
1258     UBI opval = LTSI (OPRND (src1), OPRND (src2));
1259     CPU (h_cond) = opval;
1260     TRACE_RESULT (current_cpu, "condbit", 'x', opval);
1261   }
1262
1263   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1264
1265 #if WITH_PROFILE_MODEL_P
1266   if (PROFILE_MODEL_P (current_cpu))
1267     {
1268       m32rx_model_mark_get_h_gr (current_cpu, abuf);
1269       m32rx_model_profile_insn (current_cpu, abuf);
1270     }
1271 #endif
1272
1273   return new_pc;
1274 #undef OPRND
1275 }
1276
1277 /* cmpi: cmpi $src2,$simm16.  */
1278
1279 CIA
1280 SEM_FN_NAME (m32rx,cmpi) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1281 {
1282   insn_t insn = SEM_INSN (sem_arg);
1283 #define OPRND(f) par_exec->operands.fmt_cmpi.f
1284   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1285   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1286   CIA UNUSED pc = PC;
1287   EXTRACT_FMT_CMPI_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
1288   EXTRACT_FMT_CMPI_CODE
1289
1290   {
1291     UBI opval = LTSI (OPRND (src2), OPRND (simm16));
1292     CPU (h_cond) = opval;
1293     TRACE_RESULT (current_cpu, "condbit", 'x', opval);
1294   }
1295
1296   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1297
1298 #if WITH_PROFILE_MODEL_P
1299   if (PROFILE_MODEL_P (current_cpu))
1300     {
1301       m32rx_model_mark_get_h_gr (current_cpu, abuf);
1302       m32rx_model_profile_insn (current_cpu, abuf);
1303     }
1304 #endif
1305
1306   return new_pc;
1307 #undef OPRND
1308 }
1309
1310 /* cmpu: cmpu $src1,$src2.  */
1311
1312 CIA
1313 SEM_FN_NAME (m32rx,cmpu) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1314 {
1315   insn_t insn = SEM_INSN (sem_arg);
1316 #define OPRND(f) par_exec->operands.fmt_cmp.f
1317   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1318   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1319   CIA UNUSED pc = PC;
1320   EXTRACT_FMT_CMP_VARS /* f-op1 f-r1 f-op2 f-r2 */
1321   EXTRACT_FMT_CMP_CODE
1322
1323   {
1324     UBI opval = LTUSI (OPRND (src1), OPRND (src2));
1325     CPU (h_cond) = opval;
1326     TRACE_RESULT (current_cpu, "condbit", 'x', opval);
1327   }
1328
1329   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1330
1331 #if WITH_PROFILE_MODEL_P
1332   if (PROFILE_MODEL_P (current_cpu))
1333     {
1334       m32rx_model_mark_get_h_gr (current_cpu, abuf);
1335       m32rx_model_profile_insn (current_cpu, abuf);
1336     }
1337 #endif
1338
1339   return new_pc;
1340 #undef OPRND
1341 }
1342
1343 /* cmpui: cmpui $src2,$simm16.  */
1344
1345 CIA
1346 SEM_FN_NAME (m32rx,cmpui) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1347 {
1348   insn_t insn = SEM_INSN (sem_arg);
1349 #define OPRND(f) par_exec->operands.fmt_cmpi.f
1350   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1351   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1352   CIA UNUSED pc = PC;
1353   EXTRACT_FMT_CMPI_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
1354   EXTRACT_FMT_CMPI_CODE
1355
1356   {
1357     UBI opval = LTUSI (OPRND (src2), OPRND (simm16));
1358     CPU (h_cond) = opval;
1359     TRACE_RESULT (current_cpu, "condbit", 'x', opval);
1360   }
1361
1362   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1363
1364 #if WITH_PROFILE_MODEL_P
1365   if (PROFILE_MODEL_P (current_cpu))
1366     {
1367       m32rx_model_mark_get_h_gr (current_cpu, abuf);
1368       m32rx_model_profile_insn (current_cpu, abuf);
1369     }
1370 #endif
1371
1372   return new_pc;
1373 #undef OPRND
1374 }
1375
1376 /* cmpeq: cmpeq $src1,$src2.  */
1377
1378 CIA
1379 SEM_FN_NAME (m32rx,cmpeq) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1380 {
1381   insn_t insn = SEM_INSN (sem_arg);
1382 #define OPRND(f) par_exec->operands.fmt_cmp.f
1383   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1384   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1385   CIA UNUSED pc = PC;
1386   EXTRACT_FMT_CMP_VARS /* f-op1 f-r1 f-op2 f-r2 */
1387   EXTRACT_FMT_CMP_CODE
1388
1389   {
1390     UBI opval = EQSI (OPRND (src1), OPRND (src2));
1391     CPU (h_cond) = opval;
1392     TRACE_RESULT (current_cpu, "condbit", 'x', opval);
1393   }
1394
1395   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1396
1397 #if WITH_PROFILE_MODEL_P
1398   if (PROFILE_MODEL_P (current_cpu))
1399     {
1400       m32rx_model_mark_get_h_gr (current_cpu, abuf);
1401       m32rx_model_profile_insn (current_cpu, abuf);
1402     }
1403 #endif
1404
1405   return new_pc;
1406 #undef OPRND
1407 }
1408
1409 /* cmpz: cmpz $src2.  */
1410
1411 CIA
1412 SEM_FN_NAME (m32rx,cmpz) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1413 {
1414   insn_t insn = SEM_INSN (sem_arg);
1415 #define OPRND(f) par_exec->operands.fmt_cmpz.f
1416   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1417   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1418   CIA UNUSED pc = PC;
1419   EXTRACT_FMT_CMPZ_VARS /* f-op1 f-r1 f-op2 f-r2 */
1420   EXTRACT_FMT_CMPZ_CODE
1421
1422   {
1423     UBI opval = EQSI (OPRND (src2), 0);
1424     CPU (h_cond) = opval;
1425     TRACE_RESULT (current_cpu, "condbit", 'x', opval);
1426   }
1427
1428   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1429
1430 #if WITH_PROFILE_MODEL_P
1431   if (PROFILE_MODEL_P (current_cpu))
1432     {
1433       m32rx_model_mark_get_h_gr (current_cpu, abuf);
1434       m32rx_model_profile_insn (current_cpu, abuf);
1435     }
1436 #endif
1437
1438   return new_pc;
1439 #undef OPRND
1440 }
1441
1442 /* div: div $dr,$sr.  */
1443
1444 CIA
1445 SEM_FN_NAME (m32rx,div) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1446 {
1447   insn_t insn = SEM_INSN (sem_arg);
1448 #define OPRND(f) par_exec->operands.fmt_div.f
1449   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1450   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1451   CIA UNUSED pc = PC;
1452   EXTRACT_FMT_DIV_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
1453   EXTRACT_FMT_DIV_CODE
1454
1455 if (NESI (OPRND (sr), 0)) {
1456   {
1457     SI opval = DIVSI (OPRND (dr), OPRND (sr));
1458     CPU (h_gr[f_r1]) = opval;
1459     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1460   }
1461 }
1462
1463   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1464
1465 #if WITH_PROFILE_MODEL_P
1466   if (PROFILE_MODEL_P (current_cpu))
1467     {
1468       m32rx_model_mark_get_h_gr (current_cpu, abuf);
1469       m32rx_model_mark_set_h_gr (current_cpu, abuf);
1470       m32rx_model_profile_insn (current_cpu, abuf);
1471     }
1472 #endif
1473
1474   return new_pc;
1475 #undef OPRND
1476 }
1477
1478 /* divu: divu $dr,$sr.  */
1479
1480 CIA
1481 SEM_FN_NAME (m32rx,divu) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1482 {
1483   insn_t insn = SEM_INSN (sem_arg);
1484 #define OPRND(f) par_exec->operands.fmt_div.f
1485   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1486   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1487   CIA UNUSED pc = PC;
1488   EXTRACT_FMT_DIV_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
1489   EXTRACT_FMT_DIV_CODE
1490
1491 if (NESI (OPRND (sr), 0)) {
1492   {
1493     SI opval = UDIVSI (OPRND (dr), OPRND (sr));
1494     CPU (h_gr[f_r1]) = opval;
1495     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1496   }
1497 }
1498
1499   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1500
1501 #if WITH_PROFILE_MODEL_P
1502   if (PROFILE_MODEL_P (current_cpu))
1503     {
1504       m32rx_model_mark_get_h_gr (current_cpu, abuf);
1505       m32rx_model_mark_set_h_gr (current_cpu, abuf);
1506       m32rx_model_profile_insn (current_cpu, abuf);
1507     }
1508 #endif
1509
1510   return new_pc;
1511 #undef OPRND
1512 }
1513
1514 /* rem: rem $dr,$sr.  */
1515
1516 CIA
1517 SEM_FN_NAME (m32rx,rem) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1518 {
1519   insn_t insn = SEM_INSN (sem_arg);
1520 #define OPRND(f) par_exec->operands.fmt_div.f
1521   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1522   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1523   CIA UNUSED pc = PC;
1524   EXTRACT_FMT_DIV_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
1525   EXTRACT_FMT_DIV_CODE
1526
1527 if (NESI (OPRND (sr), 0)) {
1528   {
1529     SI opval = MODSI (OPRND (dr), OPRND (sr));
1530     CPU (h_gr[f_r1]) = opval;
1531     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1532   }
1533 }
1534
1535   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1536
1537 #if WITH_PROFILE_MODEL_P
1538   if (PROFILE_MODEL_P (current_cpu))
1539     {
1540       m32rx_model_mark_get_h_gr (current_cpu, abuf);
1541       m32rx_model_mark_set_h_gr (current_cpu, abuf);
1542       m32rx_model_profile_insn (current_cpu, abuf);
1543     }
1544 #endif
1545
1546   return new_pc;
1547 #undef OPRND
1548 }
1549
1550 /* remu: remu $dr,$sr.  */
1551
1552 CIA
1553 SEM_FN_NAME (m32rx,remu) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1554 {
1555   insn_t insn = SEM_INSN (sem_arg);
1556 #define OPRND(f) par_exec->operands.fmt_div.f
1557   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1558   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1559   CIA UNUSED pc = PC;
1560   EXTRACT_FMT_DIV_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
1561   EXTRACT_FMT_DIV_CODE
1562
1563 if (NESI (OPRND (sr), 0)) {
1564   {
1565     SI opval = UMODSI (OPRND (dr), OPRND (sr));
1566     CPU (h_gr[f_r1]) = opval;
1567     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1568   }
1569 }
1570
1571   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1572
1573 #if WITH_PROFILE_MODEL_P
1574   if (PROFILE_MODEL_P (current_cpu))
1575     {
1576       m32rx_model_mark_get_h_gr (current_cpu, abuf);
1577       m32rx_model_mark_set_h_gr (current_cpu, abuf);
1578       m32rx_model_profile_insn (current_cpu, abuf);
1579     }
1580 #endif
1581
1582   return new_pc;
1583 #undef OPRND
1584 }
1585
1586 /* divh: divh $dr,$sr.  */
1587
1588 CIA
1589 SEM_FN_NAME (m32rx,divh) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1590 {
1591   insn_t insn = SEM_INSN (sem_arg);
1592 #define OPRND(f) par_exec->operands.fmt_div.f
1593   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1594   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1595   CIA UNUSED pc = PC;
1596   EXTRACT_FMT_DIV_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
1597   EXTRACT_FMT_DIV_CODE
1598
1599 if (NESI (OPRND (sr), 0)) {
1600   {
1601     SI opval = DIVSI (EXTHISI (TRUNCSIHI (OPRND (dr))), OPRND (sr));
1602     CPU (h_gr[f_r1]) = opval;
1603     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1604   }
1605 }
1606
1607   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1608
1609 #if WITH_PROFILE_MODEL_P
1610   if (PROFILE_MODEL_P (current_cpu))
1611     {
1612       m32rx_model_mark_get_h_gr (current_cpu, abuf);
1613       m32rx_model_mark_set_h_gr (current_cpu, abuf);
1614       m32rx_model_profile_insn (current_cpu, abuf);
1615     }
1616 #endif
1617
1618   return new_pc;
1619 #undef OPRND
1620 }
1621
1622 /* jc: jc $sr.  */
1623
1624 CIA
1625 SEM_FN_NAME (m32rx,jc) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1626 {
1627   insn_t insn = SEM_INSN (sem_arg);
1628 #define OPRND(f) par_exec->operands.fmt_jc.f
1629   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1630   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1631   int taken_p = 0;
1632   CIA UNUSED pc = PC;
1633   EXTRACT_FMT_JC_VARS /* f-op1 f-r1 f-op2 f-r2 */
1634   EXTRACT_FMT_JC_CODE
1635
1636 if (OPRND (condbit)) {
1637   {
1638     USI opval = ANDSI (OPRND (sr), -4);
1639     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
1640     taken_p = 1;
1641     TRACE_RESULT (current_cpu, "pc", 'x', opval);
1642   }
1643 }
1644
1645   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1646
1647 #if WITH_PROFILE_MODEL_P
1648   if (PROFILE_MODEL_P (current_cpu))
1649     {
1650       m32rx_model_mark_get_h_gr (current_cpu, abuf);
1651       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
1652     }
1653 #endif
1654
1655   return new_pc;
1656 #undef OPRND
1657 }
1658
1659 /* jnc: jnc $sr.  */
1660
1661 CIA
1662 SEM_FN_NAME (m32rx,jnc) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1663 {
1664   insn_t insn = SEM_INSN (sem_arg);
1665 #define OPRND(f) par_exec->operands.fmt_jc.f
1666   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1667   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1668   int taken_p = 0;
1669   CIA UNUSED pc = PC;
1670   EXTRACT_FMT_JC_VARS /* f-op1 f-r1 f-op2 f-r2 */
1671   EXTRACT_FMT_JC_CODE
1672
1673 if (NOTBI (OPRND (condbit))) {
1674   {
1675     USI opval = ANDSI (OPRND (sr), -4);
1676     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
1677     taken_p = 1;
1678     TRACE_RESULT (current_cpu, "pc", 'x', opval);
1679   }
1680 }
1681
1682   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1683
1684 #if WITH_PROFILE_MODEL_P
1685   if (PROFILE_MODEL_P (current_cpu))
1686     {
1687       m32rx_model_mark_get_h_gr (current_cpu, abuf);
1688       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
1689     }
1690 #endif
1691
1692   return new_pc;
1693 #undef OPRND
1694 }
1695
1696 /* jl: jl $sr.  */
1697
1698 CIA
1699 SEM_FN_NAME (m32rx,jl) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1700 {
1701   insn_t insn = SEM_INSN (sem_arg);
1702 #define OPRND(f) par_exec->operands.fmt_jl.f
1703   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1704   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1705   int taken_p = 0;
1706   CIA UNUSED pc = PC;
1707   EXTRACT_FMT_JL_VARS /* f-op1 f-r1 f-op2 f-r2 */
1708   EXTRACT_FMT_JL_CODE
1709
1710 do {
1711   USI temp1;SI temp0;
1712   temp0 = ADDSI (ANDSI (OPRND (pc), -4), 4);
1713   temp1 = ANDSI (OPRND (sr), -4);
1714   {
1715     SI opval = temp0;
1716     CPU (h_gr[((HOSTUINT) 14)]) = opval;
1717     TRACE_RESULT (current_cpu, "gr-14", 'x', opval);
1718   }
1719   {
1720     USI opval = temp1;
1721     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
1722     taken_p = 1;
1723     TRACE_RESULT (current_cpu, "pc", 'x', opval);
1724   }
1725 } while (0);
1726
1727   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1728
1729 #if WITH_PROFILE_MODEL_P
1730   if (PROFILE_MODEL_P (current_cpu))
1731     {
1732       m32rx_model_mark_get_h_gr (current_cpu, abuf);
1733       m32rx_model_mark_set_h_gr (current_cpu, abuf);
1734       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
1735     }
1736 #endif
1737
1738   return new_pc;
1739 #undef OPRND
1740 }
1741
1742 /* jmp: jmp $sr.  */
1743
1744 CIA
1745 SEM_FN_NAME (m32rx,jmp) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1746 {
1747   insn_t insn = SEM_INSN (sem_arg);
1748 #define OPRND(f) par_exec->operands.fmt_jmp.f
1749   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1750   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1751   int taken_p = 0;
1752   CIA UNUSED pc = PC;
1753   EXTRACT_FMT_JMP_VARS /* f-op1 f-r1 f-op2 f-r2 */
1754   EXTRACT_FMT_JMP_CODE
1755
1756   {
1757     USI opval = ANDSI (OPRND (sr), -4);
1758     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
1759     taken_p = 1;
1760     TRACE_RESULT (current_cpu, "pc", 'x', opval);
1761   }
1762
1763   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1764
1765 #if WITH_PROFILE_MODEL_P
1766   if (PROFILE_MODEL_P (current_cpu))
1767     {
1768       m32rx_model_mark_get_h_gr (current_cpu, abuf);
1769       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
1770     }
1771 #endif
1772
1773   return new_pc;
1774 #undef OPRND
1775 }
1776
1777 /* ld: ld $dr,@$sr.  */
1778
1779 CIA
1780 SEM_FN_NAME (m32rx,ld) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1781 {
1782   insn_t insn = SEM_INSN (sem_arg);
1783 #define OPRND(f) par_exec->operands.fmt_ld.f
1784   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1785   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1786   CIA UNUSED pc = PC;
1787   EXTRACT_FMT_LD_VARS /* f-op1 f-r1 f-op2 f-r2 */
1788   EXTRACT_FMT_LD_CODE
1789
1790   {
1791     SI opval = OPRND (h_memory_sr);
1792     CPU (h_gr[f_r1]) = opval;
1793     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1794   }
1795
1796   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1797
1798 #if WITH_PROFILE_MODEL_P
1799   if (PROFILE_MODEL_P (current_cpu))
1800     {
1801       m32rx_model_mark_get_h_gr (current_cpu, abuf);
1802       m32rx_model_mark_set_h_gr (current_cpu, abuf);
1803       m32rx_model_profile_insn (current_cpu, abuf);
1804     }
1805 #endif
1806
1807   return new_pc;
1808 #undef OPRND
1809 }
1810
1811 /* ld-d: ld $dr,@($slo16,$sr).  */
1812
1813 CIA
1814 SEM_FN_NAME (m32rx,ld_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1815 {
1816   insn_t insn = SEM_INSN (sem_arg);
1817 #define OPRND(f) par_exec->operands.fmt_ld_d.f
1818   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1819   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1820   CIA UNUSED pc = PC;
1821   EXTRACT_FMT_LD_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
1822   EXTRACT_FMT_LD_D_CODE
1823
1824   {
1825     SI opval = OPRND (h_memory_add__VM_sr_slo16);
1826     CPU (h_gr[f_r1]) = opval;
1827     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1828   }
1829
1830   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1831
1832 #if WITH_PROFILE_MODEL_P
1833   if (PROFILE_MODEL_P (current_cpu))
1834     {
1835       m32rx_model_mark_get_h_gr (current_cpu, abuf);
1836       m32rx_model_mark_set_h_gr (current_cpu, abuf);
1837       m32rx_model_profile_insn (current_cpu, abuf);
1838     }
1839 #endif
1840
1841   return new_pc;
1842 #undef OPRND
1843 }
1844
1845 /* ldb: ldb $dr,@$sr.  */
1846
1847 CIA
1848 SEM_FN_NAME (m32rx,ldb) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1849 {
1850   insn_t insn = SEM_INSN (sem_arg);
1851 #define OPRND(f) par_exec->operands.fmt_ldb.f
1852   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1853   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1854   CIA UNUSED pc = PC;
1855   EXTRACT_FMT_LDB_VARS /* f-op1 f-r1 f-op2 f-r2 */
1856   EXTRACT_FMT_LDB_CODE
1857
1858   {
1859     SI opval = EXTQISI (OPRND (h_memory_sr));
1860     CPU (h_gr[f_r1]) = opval;
1861     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1862   }
1863
1864   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1865
1866 #if WITH_PROFILE_MODEL_P
1867   if (PROFILE_MODEL_P (current_cpu))
1868     {
1869       m32rx_model_mark_get_h_gr (current_cpu, abuf);
1870       m32rx_model_mark_set_h_gr (current_cpu, abuf);
1871       m32rx_model_profile_insn (current_cpu, abuf);
1872     }
1873 #endif
1874
1875   return new_pc;
1876 #undef OPRND
1877 }
1878
1879 /* ldb-d: ldb $dr,@($slo16,$sr).  */
1880
1881 CIA
1882 SEM_FN_NAME (m32rx,ldb_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1883 {
1884   insn_t insn = SEM_INSN (sem_arg);
1885 #define OPRND(f) par_exec->operands.fmt_ldb_d.f
1886   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1887   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1888   CIA UNUSED pc = PC;
1889   EXTRACT_FMT_LDB_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
1890   EXTRACT_FMT_LDB_D_CODE
1891
1892   {
1893     SI opval = EXTQISI (OPRND (h_memory_add__VM_sr_slo16));
1894     CPU (h_gr[f_r1]) = opval;
1895     TRACE_RESULT (current_cpu, "dr", 'x', 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       m32rx_model_mark_get_h_gr (current_cpu, abuf);
1904       m32rx_model_mark_set_h_gr (current_cpu, abuf);
1905       m32rx_model_profile_insn (current_cpu, abuf);
1906     }
1907 #endif
1908
1909   return new_pc;
1910 #undef OPRND
1911 }
1912
1913 /* ldh: ldh $dr,@$sr.  */
1914
1915 CIA
1916 SEM_FN_NAME (m32rx,ldh) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1917 {
1918   insn_t insn = SEM_INSN (sem_arg);
1919 #define OPRND(f) par_exec->operands.fmt_ldh.f
1920   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1921   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1922   CIA UNUSED pc = PC;
1923   EXTRACT_FMT_LDH_VARS /* f-op1 f-r1 f-op2 f-r2 */
1924   EXTRACT_FMT_LDH_CODE
1925
1926   {
1927     SI opval = EXTHISI (OPRND (h_memory_sr));
1928     CPU (h_gr[f_r1]) = opval;
1929     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1930   }
1931
1932   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1933
1934 #if WITH_PROFILE_MODEL_P
1935   if (PROFILE_MODEL_P (current_cpu))
1936     {
1937       m32rx_model_mark_get_h_gr (current_cpu, abuf);
1938       m32rx_model_mark_set_h_gr (current_cpu, abuf);
1939       m32rx_model_profile_insn (current_cpu, abuf);
1940     }
1941 #endif
1942
1943   return new_pc;
1944 #undef OPRND
1945 }
1946
1947 /* ldh-d: ldh $dr,@($slo16,$sr).  */
1948
1949 CIA
1950 SEM_FN_NAME (m32rx,ldh_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1951 {
1952   insn_t insn = SEM_INSN (sem_arg);
1953 #define OPRND(f) par_exec->operands.fmt_ldh_d.f
1954   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1955   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
1956   CIA UNUSED pc = PC;
1957   EXTRACT_FMT_LDH_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
1958   EXTRACT_FMT_LDH_D_CODE
1959
1960   {
1961     SI opval = EXTHISI (OPRND (h_memory_add__VM_sr_slo16));
1962     CPU (h_gr[f_r1]) = opval;
1963     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1964   }
1965
1966   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
1967
1968 #if WITH_PROFILE_MODEL_P
1969   if (PROFILE_MODEL_P (current_cpu))
1970     {
1971       m32rx_model_mark_get_h_gr (current_cpu, abuf);
1972       m32rx_model_mark_set_h_gr (current_cpu, abuf);
1973       m32rx_model_profile_insn (current_cpu, abuf);
1974     }
1975 #endif
1976
1977   return new_pc;
1978 #undef OPRND
1979 }
1980
1981 /* ldub: ldub $dr,@$sr.  */
1982
1983 CIA
1984 SEM_FN_NAME (m32rx,ldub) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
1985 {
1986   insn_t insn = SEM_INSN (sem_arg);
1987 #define OPRND(f) par_exec->operands.fmt_ldb.f
1988   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1989   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
1990   CIA UNUSED pc = PC;
1991   EXTRACT_FMT_LDB_VARS /* f-op1 f-r1 f-op2 f-r2 */
1992   EXTRACT_FMT_LDB_CODE
1993
1994   {
1995     SI opval = ZEXTQISI (OPRND (h_memory_sr));
1996     CPU (h_gr[f_r1]) = opval;
1997     TRACE_RESULT (current_cpu, "dr", 'x', opval);
1998   }
1999
2000   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2001
2002 #if WITH_PROFILE_MODEL_P
2003   if (PROFILE_MODEL_P (current_cpu))
2004     {
2005       m32rx_model_mark_get_h_gr (current_cpu, abuf);
2006       m32rx_model_mark_set_h_gr (current_cpu, abuf);
2007       m32rx_model_profile_insn (current_cpu, abuf);
2008     }
2009 #endif
2010
2011   return new_pc;
2012 #undef OPRND
2013 }
2014
2015 /* ldub-d: ldub $dr,@($slo16,$sr).  */
2016
2017 CIA
2018 SEM_FN_NAME (m32rx,ldub_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2019 {
2020   insn_t insn = SEM_INSN (sem_arg);
2021 #define OPRND(f) par_exec->operands.fmt_ldb_d.f
2022   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2023   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
2024   CIA UNUSED pc = PC;
2025   EXTRACT_FMT_LDB_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
2026   EXTRACT_FMT_LDB_D_CODE
2027
2028   {
2029     SI opval = ZEXTQISI (OPRND (h_memory_add__VM_sr_slo16));
2030     CPU (h_gr[f_r1]) = opval;
2031     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2032   }
2033
2034   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2035
2036 #if WITH_PROFILE_MODEL_P
2037   if (PROFILE_MODEL_P (current_cpu))
2038     {
2039       m32rx_model_mark_get_h_gr (current_cpu, abuf);
2040       m32rx_model_mark_set_h_gr (current_cpu, abuf);
2041       m32rx_model_profile_insn (current_cpu, abuf);
2042     }
2043 #endif
2044
2045   return new_pc;
2046 #undef OPRND
2047 }
2048
2049 /* lduh: lduh $dr,@$sr.  */
2050
2051 CIA
2052 SEM_FN_NAME (m32rx,lduh) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2053 {
2054   insn_t insn = SEM_INSN (sem_arg);
2055 #define OPRND(f) par_exec->operands.fmt_ldh.f
2056   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2057   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2058   CIA UNUSED pc = PC;
2059   EXTRACT_FMT_LDH_VARS /* f-op1 f-r1 f-op2 f-r2 */
2060   EXTRACT_FMT_LDH_CODE
2061
2062   {
2063     SI opval = ZEXTHISI (OPRND (h_memory_sr));
2064     CPU (h_gr[f_r1]) = opval;
2065     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2066   }
2067
2068   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2069
2070 #if WITH_PROFILE_MODEL_P
2071   if (PROFILE_MODEL_P (current_cpu))
2072     {
2073       m32rx_model_mark_get_h_gr (current_cpu, abuf);
2074       m32rx_model_mark_set_h_gr (current_cpu, abuf);
2075       m32rx_model_profile_insn (current_cpu, abuf);
2076     }
2077 #endif
2078
2079   return new_pc;
2080 #undef OPRND
2081 }
2082
2083 /* lduh-d: lduh $dr,@($slo16,$sr).  */
2084
2085 CIA
2086 SEM_FN_NAME (m32rx,lduh_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2087 {
2088   insn_t insn = SEM_INSN (sem_arg);
2089 #define OPRND(f) par_exec->operands.fmt_ldh_d.f
2090   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2091   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
2092   CIA UNUSED pc = PC;
2093   EXTRACT_FMT_LDH_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
2094   EXTRACT_FMT_LDH_D_CODE
2095
2096   {
2097     SI opval = ZEXTHISI (OPRND (h_memory_add__VM_sr_slo16));
2098     CPU (h_gr[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       m32rx_model_mark_get_h_gr (current_cpu, abuf);
2108       m32rx_model_mark_set_h_gr (current_cpu, abuf);
2109       m32rx_model_profile_insn (current_cpu, abuf);
2110     }
2111 #endif
2112
2113   return new_pc;
2114 #undef OPRND
2115 }
2116
2117 /* ld-plus: ld $dr,@$sr+.  */
2118
2119 CIA
2120 SEM_FN_NAME (m32rx,ld_plus) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2121 {
2122   insn_t insn = SEM_INSN (sem_arg);
2123 #define OPRND(f) par_exec->operands.fmt_ld_plus.f
2124   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2125   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2126   CIA UNUSED pc = PC;
2127   EXTRACT_FMT_LD_PLUS_VARS /* f-op1 f-r1 f-op2 f-r2 */
2128   EXTRACT_FMT_LD_PLUS_CODE
2129
2130 do {
2131   SI temp1;SI temp0;
2132   temp0 = OPRND (h_memory_sr);
2133   temp1 = ADDSI (OPRND (sr), 4);
2134   {
2135     SI opval = temp0;
2136     CPU (h_gr[f_r1]) = opval;
2137     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2138   }
2139   {
2140     SI opval = temp1;
2141     CPU (h_gr[f_r2]) = opval;
2142     TRACE_RESULT (current_cpu, "sr", 'x', opval);
2143   }
2144 } while (0);
2145
2146   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2147
2148 #if WITH_PROFILE_MODEL_P
2149   if (PROFILE_MODEL_P (current_cpu))
2150     {
2151       m32rx_model_mark_get_h_gr (current_cpu, abuf);
2152       m32rx_model_mark_set_h_gr (current_cpu, abuf);
2153       m32rx_model_profile_insn (current_cpu, abuf);
2154     }
2155 #endif
2156
2157   return new_pc;
2158 #undef OPRND
2159 }
2160
2161 /* ld24: ld24 $dr,$uimm24.  */
2162
2163 CIA
2164 SEM_FN_NAME (m32rx,ld24) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2165 {
2166   insn_t insn = SEM_INSN (sem_arg);
2167 #define OPRND(f) par_exec->operands.fmt_ld24.f
2168   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2169   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
2170   CIA UNUSED pc = PC;
2171   EXTRACT_FMT_LD24_VARS /* f-op1 f-r1 f-uimm24 */
2172   EXTRACT_FMT_LD24_CODE
2173
2174   {
2175     SI opval = OPRND (uimm24);
2176     CPU (h_gr[f_r1]) = opval;
2177     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2178   }
2179
2180   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2181
2182 #if WITH_PROFILE_MODEL_P
2183   if (PROFILE_MODEL_P (current_cpu))
2184     {
2185       m32rx_model_mark_set_h_gr (current_cpu, abuf);
2186       m32rx_model_profile_insn (current_cpu, abuf);
2187     }
2188 #endif
2189
2190   return new_pc;
2191 #undef OPRND
2192 }
2193
2194 /* ldi8: ldi8 $dr,$simm8.  */
2195
2196 CIA
2197 SEM_FN_NAME (m32rx,ldi8) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2198 {
2199   insn_t insn = SEM_INSN (sem_arg);
2200 #define OPRND(f) par_exec->operands.fmt_ldi8.f
2201   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2202   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2203   CIA UNUSED pc = PC;
2204   EXTRACT_FMT_LDI8_VARS /* f-op1 f-r1 f-simm8 */
2205   EXTRACT_FMT_LDI8_CODE
2206
2207   {
2208     SI opval = OPRND (simm8);
2209     CPU (h_gr[f_r1]) = opval;
2210     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2211   }
2212
2213   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2214
2215 #if WITH_PROFILE_MODEL_P
2216   if (PROFILE_MODEL_P (current_cpu))
2217     {
2218       m32rx_model_mark_set_h_gr (current_cpu, abuf);
2219       m32rx_model_profile_insn (current_cpu, abuf);
2220     }
2221 #endif
2222
2223   return new_pc;
2224 #undef OPRND
2225 }
2226
2227 /* ldi16: ldi16 $dr,$hash$slo16.  */
2228
2229 CIA
2230 SEM_FN_NAME (m32rx,ldi16) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2231 {
2232   insn_t insn = SEM_INSN (sem_arg);
2233 #define OPRND(f) par_exec->operands.fmt_ldi16.f
2234   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2235   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
2236   CIA UNUSED pc = PC;
2237   EXTRACT_FMT_LDI16_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
2238   EXTRACT_FMT_LDI16_CODE
2239
2240   {
2241     SI opval = OPRND (slo16);
2242     CPU (h_gr[f_r1]) = opval;
2243     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2244   }
2245
2246   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2247
2248 #if WITH_PROFILE_MODEL_P
2249   if (PROFILE_MODEL_P (current_cpu))
2250     {
2251       m32rx_model_mark_set_h_gr (current_cpu, abuf);
2252       m32rx_model_profile_insn (current_cpu, abuf);
2253     }
2254 #endif
2255
2256   return new_pc;
2257 #undef OPRND
2258 }
2259
2260 /* lock: lock $dr,@$sr.  */
2261
2262 CIA
2263 SEM_FN_NAME (m32rx,lock) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2264 {
2265   insn_t insn = SEM_INSN (sem_arg);
2266 #define OPRND(f) par_exec->operands.fmt_lock.f
2267   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2268   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2269   CIA UNUSED pc = PC;
2270   EXTRACT_FMT_LOCK_VARS /* f-op1 f-r1 f-op2 f-r2 */
2271   EXTRACT_FMT_LOCK_CODE
2272
2273 do {
2274   {
2275     UBI opval = 1;
2276     CPU (h_lock) = opval;
2277     TRACE_RESULT (current_cpu, "lock-0", 'x', opval);
2278   }
2279   {
2280     SI opval = OPRND (h_memory_sr);
2281     CPU (h_gr[f_r1]) = opval;
2282     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2283   }
2284 } while (0);
2285
2286   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2287
2288 #if WITH_PROFILE_MODEL_P
2289   if (PROFILE_MODEL_P (current_cpu))
2290     {
2291       m32rx_model_mark_get_h_gr (current_cpu, abuf);
2292       m32rx_model_mark_set_h_gr (current_cpu, abuf);
2293       m32rx_model_profile_insn (current_cpu, abuf);
2294     }
2295 #endif
2296
2297   return new_pc;
2298 #undef OPRND
2299 }
2300
2301 /* machi-a: machi $src1,$src2,$acc.  */
2302
2303 CIA
2304 SEM_FN_NAME (m32rx,machi_a) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2305 {
2306   insn_t insn = SEM_INSN (sem_arg);
2307 #define OPRND(f) par_exec->operands.fmt_machi_a.f
2308   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2309   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2310   CIA UNUSED pc = PC;
2311   EXTRACT_FMT_MACHI_A_VARS /* f-op1 f-r1 f-acc f-op23 f-r2 */
2312   EXTRACT_FMT_MACHI_A_CODE
2313
2314   {
2315     DI opval = SRADI (SLLDI (ADDDI (OPRND (acc), MULDI (EXTSIDI (ANDSI (OPRND (src1), 0xffff0000)), EXTHIDI (TRUNCSIHI (SRASI (OPRND (src2), 16))))), 8), 8);
2316     m32rx_h_accums_set (current_cpu, f_acc, opval);
2317     TRACE_RESULT (current_cpu, "acc", 'D', opval);
2318   }
2319
2320   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2321
2322 #if WITH_PROFILE_MODEL_P
2323   if (PROFILE_MODEL_P (current_cpu))
2324     {
2325       m32rx_model_mark_get_h_gr (current_cpu, abuf);
2326       m32rx_model_profile_insn (current_cpu, abuf);
2327     }
2328 #endif
2329
2330   return new_pc;
2331 #undef OPRND
2332 }
2333
2334 /* maclo-a: maclo $src1,$src2,$acc.  */
2335
2336 CIA
2337 SEM_FN_NAME (m32rx,maclo_a) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2338 {
2339   insn_t insn = SEM_INSN (sem_arg);
2340 #define OPRND(f) par_exec->operands.fmt_machi_a.f
2341   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2342   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2343   CIA UNUSED pc = PC;
2344   EXTRACT_FMT_MACHI_A_VARS /* f-op1 f-r1 f-acc f-op23 f-r2 */
2345   EXTRACT_FMT_MACHI_A_CODE
2346
2347   {
2348     DI opval = SRADI (SLLDI (ADDDI (OPRND (acc), MULDI (EXTSIDI (SLLSI (OPRND (src1), 16)), EXTHIDI (TRUNCSIHI (OPRND (src2))))), 8), 8);
2349     m32rx_h_accums_set (current_cpu, f_acc, opval);
2350     TRACE_RESULT (current_cpu, "acc", 'D', opval);
2351   }
2352
2353   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2354
2355 #if WITH_PROFILE_MODEL_P
2356   if (PROFILE_MODEL_P (current_cpu))
2357     {
2358       m32rx_model_mark_get_h_gr (current_cpu, abuf);
2359       m32rx_model_profile_insn (current_cpu, abuf);
2360     }
2361 #endif
2362
2363   return new_pc;
2364 #undef OPRND
2365 }
2366
2367 /* macwhi: macwhi $src1,$src2.  */
2368
2369 CIA
2370 SEM_FN_NAME (m32rx,macwhi) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2371 {
2372   insn_t insn = SEM_INSN (sem_arg);
2373 #define OPRND(f) par_exec->operands.fmt_macwhi.f
2374   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2375   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2376   CIA UNUSED pc = PC;
2377   EXTRACT_FMT_MACWHI_VARS /* f-op1 f-r1 f-op2 f-r2 */
2378   EXTRACT_FMT_MACWHI_CODE
2379
2380   {
2381     DI opval = SRADI (SLLDI (ADDDI (OPRND (accum), MULDI (EXTSIDI (OPRND (src1)), EXTHIDI (TRUNCSIHI (SRASI (OPRND (src2), 16))))), 8), 8);
2382     m32rx_h_accum_set (current_cpu, opval);
2383     TRACE_RESULT (current_cpu, "accum", 'D', opval);
2384   }
2385
2386   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2387
2388 #if WITH_PROFILE_MODEL_P
2389   if (PROFILE_MODEL_P (current_cpu))
2390     {
2391       m32rx_model_mark_get_h_gr (current_cpu, abuf);
2392       m32rx_model_profile_insn (current_cpu, abuf);
2393     }
2394 #endif
2395
2396   return new_pc;
2397 #undef OPRND
2398 }
2399
2400 /* macwlo: macwlo $src1,$src2.  */
2401
2402 CIA
2403 SEM_FN_NAME (m32rx,macwlo) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2404 {
2405   insn_t insn = SEM_INSN (sem_arg);
2406 #define OPRND(f) par_exec->operands.fmt_macwhi.f
2407   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2408   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2409   CIA UNUSED pc = PC;
2410   EXTRACT_FMT_MACWHI_VARS /* f-op1 f-r1 f-op2 f-r2 */
2411   EXTRACT_FMT_MACWHI_CODE
2412
2413   {
2414     DI opval = SRADI (SLLDI (ADDDI (OPRND (accum), MULDI (EXTSIDI (OPRND (src1)), EXTHIDI (TRUNCSIHI (OPRND (src2))))), 8), 8);
2415     m32rx_h_accum_set (current_cpu, opval);
2416     TRACE_RESULT (current_cpu, "accum", 'D', opval);
2417   }
2418
2419   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2420
2421 #if WITH_PROFILE_MODEL_P
2422   if (PROFILE_MODEL_P (current_cpu))
2423     {
2424       m32rx_model_mark_get_h_gr (current_cpu, abuf);
2425       m32rx_model_profile_insn (current_cpu, abuf);
2426     }
2427 #endif
2428
2429   return new_pc;
2430 #undef OPRND
2431 }
2432
2433 /* mul: mul $dr,$sr.  */
2434
2435 CIA
2436 SEM_FN_NAME (m32rx,mul) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2437 {
2438   insn_t insn = SEM_INSN (sem_arg);
2439 #define OPRND(f) par_exec->operands.fmt_add.f
2440   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2441   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2442   CIA UNUSED pc = PC;
2443   EXTRACT_FMT_ADD_VARS /* f-op1 f-r1 f-op2 f-r2 */
2444   EXTRACT_FMT_ADD_CODE
2445
2446   {
2447     SI opval = MULSI (OPRND (dr), OPRND (sr));
2448     CPU (h_gr[f_r1]) = opval;
2449     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2450   }
2451
2452   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2453
2454 #if WITH_PROFILE_MODEL_P
2455   if (PROFILE_MODEL_P (current_cpu))
2456     {
2457       m32rx_model_mark_get_h_gr (current_cpu, abuf);
2458       m32rx_model_mark_set_h_gr (current_cpu, abuf);
2459       m32rx_model_profile_insn (current_cpu, abuf);
2460     }
2461 #endif
2462
2463   return new_pc;
2464 #undef OPRND
2465 }
2466
2467 /* mulhi-a: mulhi $src1,$src2,$acc.  */
2468
2469 CIA
2470 SEM_FN_NAME (m32rx,mulhi_a) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2471 {
2472   insn_t insn = SEM_INSN (sem_arg);
2473 #define OPRND(f) par_exec->operands.fmt_mulhi_a.f
2474   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2475   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2476   CIA UNUSED pc = PC;
2477   EXTRACT_FMT_MULHI_A_VARS /* f-op1 f-r1 f-acc f-op23 f-r2 */
2478   EXTRACT_FMT_MULHI_A_CODE
2479
2480   {
2481     DI opval = SRADI (SLLDI (MULDI (EXTSIDI (ANDSI (OPRND (src1), 0xffff0000)), EXTHIDI (TRUNCSIHI (SRASI (OPRND (src2), 16)))), 16), 16);
2482     m32rx_h_accums_set (current_cpu, f_acc, opval);
2483     TRACE_RESULT (current_cpu, "acc", 'D', opval);
2484   }
2485
2486   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2487
2488 #if WITH_PROFILE_MODEL_P
2489   if (PROFILE_MODEL_P (current_cpu))
2490     {
2491       m32rx_model_mark_get_h_gr (current_cpu, abuf);
2492       m32rx_model_profile_insn (current_cpu, abuf);
2493     }
2494 #endif
2495
2496   return new_pc;
2497 #undef OPRND
2498 }
2499
2500 /* mullo-a: mullo $src1,$src2,$acc.  */
2501
2502 CIA
2503 SEM_FN_NAME (m32rx,mullo_a) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2504 {
2505   insn_t insn = SEM_INSN (sem_arg);
2506 #define OPRND(f) par_exec->operands.fmt_mulhi_a.f
2507   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2508   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2509   CIA UNUSED pc = PC;
2510   EXTRACT_FMT_MULHI_A_VARS /* f-op1 f-r1 f-acc f-op23 f-r2 */
2511   EXTRACT_FMT_MULHI_A_CODE
2512
2513   {
2514     DI opval = SRADI (SLLDI (MULDI (EXTSIDI (SLLSI (OPRND (src1), 16)), EXTHIDI (TRUNCSIHI (OPRND (src2)))), 16), 16);
2515     m32rx_h_accums_set (current_cpu, f_acc, opval);
2516     TRACE_RESULT (current_cpu, "acc", 'D', opval);
2517   }
2518
2519   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2520
2521 #if WITH_PROFILE_MODEL_P
2522   if (PROFILE_MODEL_P (current_cpu))
2523     {
2524       m32rx_model_mark_get_h_gr (current_cpu, abuf);
2525       m32rx_model_profile_insn (current_cpu, abuf);
2526     }
2527 #endif
2528
2529   return new_pc;
2530 #undef OPRND
2531 }
2532
2533 /* mulwhi: mulwhi $src1,$src2.  */
2534
2535 CIA
2536 SEM_FN_NAME (m32rx,mulwhi) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2537 {
2538   insn_t insn = SEM_INSN (sem_arg);
2539 #define OPRND(f) par_exec->operands.fmt_mulwhi.f
2540   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2541   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2542   CIA UNUSED pc = PC;
2543   EXTRACT_FMT_MULWHI_VARS /* f-op1 f-r1 f-op2 f-r2 */
2544   EXTRACT_FMT_MULWHI_CODE
2545
2546   {
2547     DI opval = SRADI (SLLDI (MULDI (EXTSIDI (OPRND (src1)), EXTHIDI (TRUNCSIHI (SRASI (OPRND (src2), 16)))), 8), 8);
2548     m32rx_h_accum_set (current_cpu, opval);
2549     TRACE_RESULT (current_cpu, "accum", 'D', opval);
2550   }
2551
2552   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2553
2554 #if WITH_PROFILE_MODEL_P
2555   if (PROFILE_MODEL_P (current_cpu))
2556     {
2557       m32rx_model_mark_get_h_gr (current_cpu, abuf);
2558       m32rx_model_profile_insn (current_cpu, abuf);
2559     }
2560 #endif
2561
2562   return new_pc;
2563 #undef OPRND
2564 }
2565
2566 /* mulwlo: mulwlo $src1,$src2.  */
2567
2568 CIA
2569 SEM_FN_NAME (m32rx,mulwlo) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2570 {
2571   insn_t insn = SEM_INSN (sem_arg);
2572 #define OPRND(f) par_exec->operands.fmt_mulwhi.f
2573   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2574   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2575   CIA UNUSED pc = PC;
2576   EXTRACT_FMT_MULWHI_VARS /* f-op1 f-r1 f-op2 f-r2 */
2577   EXTRACT_FMT_MULWHI_CODE
2578
2579   {
2580     DI opval = SRADI (SLLDI (MULDI (EXTSIDI (OPRND (src1)), EXTHIDI (TRUNCSIHI (OPRND (src2)))), 8), 8);
2581     m32rx_h_accum_set (current_cpu, opval);
2582     TRACE_RESULT (current_cpu, "accum", 'D', opval);
2583   }
2584
2585   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2586
2587 #if WITH_PROFILE_MODEL_P
2588   if (PROFILE_MODEL_P (current_cpu))
2589     {
2590       m32rx_model_mark_get_h_gr (current_cpu, abuf);
2591       m32rx_model_profile_insn (current_cpu, abuf);
2592     }
2593 #endif
2594
2595   return new_pc;
2596 #undef OPRND
2597 }
2598
2599 /* mv: mv $dr,$sr.  */
2600
2601 CIA
2602 SEM_FN_NAME (m32rx,mv) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2603 {
2604   insn_t insn = SEM_INSN (sem_arg);
2605 #define OPRND(f) par_exec->operands.fmt_mv.f
2606   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2607   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2608   CIA UNUSED pc = PC;
2609   EXTRACT_FMT_MV_VARS /* f-op1 f-r1 f-op2 f-r2 */
2610   EXTRACT_FMT_MV_CODE
2611
2612   {
2613     SI opval = OPRND (sr);
2614     CPU (h_gr[f_r1]) = opval;
2615     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2616   }
2617
2618   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2619
2620 #if WITH_PROFILE_MODEL_P
2621   if (PROFILE_MODEL_P (current_cpu))
2622     {
2623       m32rx_model_mark_get_h_gr (current_cpu, abuf);
2624       m32rx_model_mark_set_h_gr (current_cpu, abuf);
2625       m32rx_model_profile_insn (current_cpu, abuf);
2626     }
2627 #endif
2628
2629   return new_pc;
2630 #undef OPRND
2631 }
2632
2633 /* mvfachi-a: mvfachi $dr,$accs.  */
2634
2635 CIA
2636 SEM_FN_NAME (m32rx,mvfachi_a) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2637 {
2638   insn_t insn = SEM_INSN (sem_arg);
2639 #define OPRND(f) par_exec->operands.fmt_mvfachi_a.f
2640   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2641   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2642   CIA UNUSED pc = PC;
2643   EXTRACT_FMT_MVFACHI_A_VARS /* f-op1 f-r1 f-op2 f-accs f-op3 */
2644   EXTRACT_FMT_MVFACHI_A_CODE
2645
2646   {
2647     SI opval = TRUNCDISI (SRADI (OPRND (accs), 32));
2648     CPU (h_gr[f_r1]) = opval;
2649     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2650   }
2651
2652   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2653
2654 #if WITH_PROFILE_MODEL_P
2655   if (PROFILE_MODEL_P (current_cpu))
2656     {
2657       m32rx_model_mark_set_h_gr (current_cpu, abuf);
2658       m32rx_model_profile_insn (current_cpu, abuf);
2659     }
2660 #endif
2661
2662   return new_pc;
2663 #undef OPRND
2664 }
2665
2666 /* mvfaclo-a: mvfaclo $dr,$accs.  */
2667
2668 CIA
2669 SEM_FN_NAME (m32rx,mvfaclo_a) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2670 {
2671   insn_t insn = SEM_INSN (sem_arg);
2672 #define OPRND(f) par_exec->operands.fmt_mvfachi_a.f
2673   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2674   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2675   CIA UNUSED pc = PC;
2676   EXTRACT_FMT_MVFACHI_A_VARS /* f-op1 f-r1 f-op2 f-accs f-op3 */
2677   EXTRACT_FMT_MVFACHI_A_CODE
2678
2679   {
2680     SI opval = TRUNCDISI (OPRND (accs));
2681     CPU (h_gr[f_r1]) = opval;
2682     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2683   }
2684
2685   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2686
2687 #if WITH_PROFILE_MODEL_P
2688   if (PROFILE_MODEL_P (current_cpu))
2689     {
2690       m32rx_model_mark_set_h_gr (current_cpu, abuf);
2691       m32rx_model_profile_insn (current_cpu, abuf);
2692     }
2693 #endif
2694
2695   return new_pc;
2696 #undef OPRND
2697 }
2698
2699 /* mvfacmi-a: mvfacmi $dr,$accs.  */
2700
2701 CIA
2702 SEM_FN_NAME (m32rx,mvfacmi_a) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2703 {
2704   insn_t insn = SEM_INSN (sem_arg);
2705 #define OPRND(f) par_exec->operands.fmt_mvfachi_a.f
2706   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2707   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2708   CIA UNUSED pc = PC;
2709   EXTRACT_FMT_MVFACHI_A_VARS /* f-op1 f-r1 f-op2 f-accs f-op3 */
2710   EXTRACT_FMT_MVFACHI_A_CODE
2711
2712   {
2713     SI opval = TRUNCDISI (SRADI (OPRND (accs), 16));
2714     CPU (h_gr[f_r1]) = opval;
2715     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2716   }
2717
2718   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2719
2720 #if WITH_PROFILE_MODEL_P
2721   if (PROFILE_MODEL_P (current_cpu))
2722     {
2723       m32rx_model_mark_set_h_gr (current_cpu, abuf);
2724       m32rx_model_profile_insn (current_cpu, abuf);
2725     }
2726 #endif
2727
2728   return new_pc;
2729 #undef OPRND
2730 }
2731
2732 /* mvfc: mvfc $dr,$scr.  */
2733
2734 CIA
2735 SEM_FN_NAME (m32rx,mvfc) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2736 {
2737   insn_t insn = SEM_INSN (sem_arg);
2738 #define OPRND(f) par_exec->operands.fmt_mvfc.f
2739   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2740   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2741   CIA UNUSED pc = PC;
2742   EXTRACT_FMT_MVFC_VARS /* f-op1 f-r1 f-op2 f-r2 */
2743   EXTRACT_FMT_MVFC_CODE
2744
2745   {
2746     SI opval = OPRND (scr);
2747     CPU (h_gr[f_r1]) = opval;
2748     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2749   }
2750
2751   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2752
2753 #if WITH_PROFILE_MODEL_P
2754   if (PROFILE_MODEL_P (current_cpu))
2755     {
2756       m32rx_model_mark_set_h_gr (current_cpu, abuf);
2757       m32rx_model_profile_insn (current_cpu, abuf);
2758     }
2759 #endif
2760
2761   return new_pc;
2762 #undef OPRND
2763 }
2764
2765 /* mvtachi-a: mvtachi $src1,$accs.  */
2766
2767 CIA
2768 SEM_FN_NAME (m32rx,mvtachi_a) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2769 {
2770   insn_t insn = SEM_INSN (sem_arg);
2771 #define OPRND(f) par_exec->operands.fmt_mvtachi_a.f
2772   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2773   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2774   CIA UNUSED pc = PC;
2775   EXTRACT_FMT_MVTACHI_A_VARS /* f-op1 f-r1 f-op2 f-accs f-op3 */
2776   EXTRACT_FMT_MVTACHI_A_CODE
2777
2778   {
2779     DI opval = ORDI (ANDDI (OPRND (accs), MAKEDI (0, 0xffffffff)), SLLDI (EXTSIDI (OPRND (src1)), 32));
2780     m32rx_h_accums_set (current_cpu, f_accs, opval);
2781     TRACE_RESULT (current_cpu, "accs", 'D', opval);
2782   }
2783
2784   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2785
2786 #if WITH_PROFILE_MODEL_P
2787   if (PROFILE_MODEL_P (current_cpu))
2788     {
2789       m32rx_model_mark_get_h_gr (current_cpu, abuf);
2790       m32rx_model_profile_insn (current_cpu, abuf);
2791     }
2792 #endif
2793
2794   return new_pc;
2795 #undef OPRND
2796 }
2797
2798 /* mvtaclo-a: mvtaclo $src1,$accs.  */
2799
2800 CIA
2801 SEM_FN_NAME (m32rx,mvtaclo_a) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2802 {
2803   insn_t insn = SEM_INSN (sem_arg);
2804 #define OPRND(f) par_exec->operands.fmt_mvtachi_a.f
2805   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2806   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2807   CIA UNUSED pc = PC;
2808   EXTRACT_FMT_MVTACHI_A_VARS /* f-op1 f-r1 f-op2 f-accs f-op3 */
2809   EXTRACT_FMT_MVTACHI_A_CODE
2810
2811   {
2812     DI opval = ORDI (ANDDI (OPRND (accs), MAKEDI (0xffffffff, 0)), ZEXTSIDI (OPRND (src1)));
2813     m32rx_h_accums_set (current_cpu, f_accs, opval);
2814     TRACE_RESULT (current_cpu, "accs", 'D', opval);
2815   }
2816
2817   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2818
2819 #if WITH_PROFILE_MODEL_P
2820   if (PROFILE_MODEL_P (current_cpu))
2821     {
2822       m32rx_model_mark_get_h_gr (current_cpu, abuf);
2823       m32rx_model_profile_insn (current_cpu, abuf);
2824     }
2825 #endif
2826
2827   return new_pc;
2828 #undef OPRND
2829 }
2830
2831 /* mvtc: mvtc $sr,$dcr.  */
2832
2833 CIA
2834 SEM_FN_NAME (m32rx,mvtc) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2835 {
2836   insn_t insn = SEM_INSN (sem_arg);
2837 #define OPRND(f) par_exec->operands.fmt_mvtc.f
2838   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2839   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2840   CIA UNUSED pc = PC;
2841   EXTRACT_FMT_MVTC_VARS /* f-op1 f-r1 f-op2 f-r2 */
2842   EXTRACT_FMT_MVTC_CODE
2843
2844   {
2845     USI opval = OPRND (sr);
2846     m32rx_h_cr_set (current_cpu, f_r1, opval);
2847     TRACE_RESULT (current_cpu, "dcr", 'x', opval);
2848   }
2849
2850   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2851
2852 #if WITH_PROFILE_MODEL_P
2853   if (PROFILE_MODEL_P (current_cpu))
2854     {
2855       m32rx_model_mark_get_h_gr (current_cpu, abuf);
2856       m32rx_model_profile_insn (current_cpu, abuf);
2857     }
2858 #endif
2859
2860   return new_pc;
2861 #undef OPRND
2862 }
2863
2864 /* neg: neg $dr,$sr.  */
2865
2866 CIA
2867 SEM_FN_NAME (m32rx,neg) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2868 {
2869   insn_t insn = SEM_INSN (sem_arg);
2870 #define OPRND(f) par_exec->operands.fmt_mv.f
2871   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2872   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2873   CIA UNUSED pc = PC;
2874   EXTRACT_FMT_MV_VARS /* f-op1 f-r1 f-op2 f-r2 */
2875   EXTRACT_FMT_MV_CODE
2876
2877   {
2878     SI opval = NEGSI (OPRND (sr));
2879     CPU (h_gr[f_r1]) = opval;
2880     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2881   }
2882
2883   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2884
2885 #if WITH_PROFILE_MODEL_P
2886   if (PROFILE_MODEL_P (current_cpu))
2887     {
2888       m32rx_model_mark_get_h_gr (current_cpu, abuf);
2889       m32rx_model_mark_set_h_gr (current_cpu, abuf);
2890       m32rx_model_profile_insn (current_cpu, abuf);
2891     }
2892 #endif
2893
2894   return new_pc;
2895 #undef OPRND
2896 }
2897
2898 /* nop: nop.  */
2899
2900 CIA
2901 SEM_FN_NAME (m32rx,nop) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2902 {
2903   insn_t insn = SEM_INSN (sem_arg);
2904 #define OPRND(f) par_exec->operands.fmt_nop.f
2905   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2906   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2907   CIA UNUSED pc = PC;
2908   EXTRACT_FMT_NOP_VARS /* f-op1 f-r1 f-op2 f-r2 */
2909   EXTRACT_FMT_NOP_CODE
2910
2911 PROFILE_COUNT_FILLNOPS (current_cpu, abuf->addr);
2912
2913   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2914
2915 #if WITH_PROFILE_MODEL_P
2916   if (PROFILE_MODEL_P (current_cpu))
2917     {
2918       m32rx_model_profile_insn (current_cpu, abuf);
2919     }
2920 #endif
2921
2922   return new_pc;
2923 #undef OPRND
2924 }
2925
2926 /* not: not $dr,$sr.  */
2927
2928 CIA
2929 SEM_FN_NAME (m32rx,not) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2930 {
2931   insn_t insn = SEM_INSN (sem_arg);
2932 #define OPRND(f) par_exec->operands.fmt_mv.f
2933   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2934   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2935   CIA UNUSED pc = PC;
2936   EXTRACT_FMT_MV_VARS /* f-op1 f-r1 f-op2 f-r2 */
2937   EXTRACT_FMT_MV_CODE
2938
2939   {
2940     SI opval = INVSI (OPRND (sr));
2941     CPU (h_gr[f_r1]) = opval;
2942     TRACE_RESULT (current_cpu, "dr", 'x', opval);
2943   }
2944
2945   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2946
2947 #if WITH_PROFILE_MODEL_P
2948   if (PROFILE_MODEL_P (current_cpu))
2949     {
2950       m32rx_model_mark_get_h_gr (current_cpu, abuf);
2951       m32rx_model_mark_set_h_gr (current_cpu, abuf);
2952       m32rx_model_profile_insn (current_cpu, abuf);
2953     }
2954 #endif
2955
2956   return new_pc;
2957 #undef OPRND
2958 }
2959
2960 /* rac-dsi: rac $accd,$accs,$imm1.  */
2961
2962 CIA
2963 SEM_FN_NAME (m32rx,rac_dsi) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
2964 {
2965   insn_t insn = SEM_INSN (sem_arg);
2966 #define OPRND(f) par_exec->operands.fmt_rac_dsi.f
2967   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2968   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
2969   CIA UNUSED pc = PC;
2970   EXTRACT_FMT_RAC_DSI_VARS /* f-op1 f-accd f-bits67 f-op2 f-accs f-bit14 f-imm1 */
2971   EXTRACT_FMT_RAC_DSI_CODE
2972
2973 do {
2974   DI tmp_tmp1;
2975   tmp_tmp1 = SLLDI (OPRND (accs), OPRND (imm1));
2976   tmp_tmp1 = ADDDI (tmp_tmp1, MAKEDI (0, 32768));
2977   {
2978     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)));
2979     m32rx_h_accums_set (current_cpu, f_accd, opval);
2980     TRACE_RESULT (current_cpu, "accd", 'D', opval);
2981   }
2982 } while (0);
2983
2984   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
2985
2986 #if WITH_PROFILE_MODEL_P
2987   if (PROFILE_MODEL_P (current_cpu))
2988     {
2989       m32rx_model_profile_insn (current_cpu, abuf);
2990     }
2991 #endif
2992
2993   return new_pc;
2994 #undef OPRND
2995 }
2996
2997 /* rach-dsi: rach $accd,$accs,$imm1.  */
2998
2999 CIA
3000 SEM_FN_NAME (m32rx,rach_dsi) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3001 {
3002   insn_t insn = SEM_INSN (sem_arg);
3003 #define OPRND(f) par_exec->operands.fmt_rac_dsi.f
3004   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3005   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
3006   CIA UNUSED pc = PC;
3007   EXTRACT_FMT_RAC_DSI_VARS /* f-op1 f-accd f-bits67 f-op2 f-accs f-bit14 f-imm1 */
3008   EXTRACT_FMT_RAC_DSI_CODE
3009
3010 do {
3011   DI tmp_tmp1;
3012   tmp_tmp1 = SLLDI (OPRND (accs), OPRND (imm1));
3013   tmp_tmp1 = ADDDI (tmp_tmp1, MAKEDI (0, 0x80000000));
3014   {
3015     DI opval = (GTDI (tmp_tmp1, MAKEDI (32767, 0))) ? (MAKEDI (32767, 0)) : (LTDI (tmp_tmp1, MAKEDI (0xffff8000, 0))) ? (MAKEDI (0xffff8000, 0)) : (ANDDI (tmp_tmp1, MAKEDI (0xffffffff, 0)));
3016     m32rx_h_accums_set (current_cpu, f_accd, opval);
3017     TRACE_RESULT (current_cpu, "accd", 'D', opval);
3018   }
3019 } while (0);
3020
3021   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3022
3023 #if WITH_PROFILE_MODEL_P
3024   if (PROFILE_MODEL_P (current_cpu))
3025     {
3026       m32rx_model_profile_insn (current_cpu, abuf);
3027     }
3028 #endif
3029
3030   return new_pc;
3031 #undef OPRND
3032 }
3033
3034 /* rte: rte.  */
3035
3036 CIA
3037 SEM_FN_NAME (m32rx,rte) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3038 {
3039   insn_t insn = SEM_INSN (sem_arg);
3040 #define OPRND(f) par_exec->operands.fmt_rte.f
3041   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3042   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
3043   int taken_p = 0;
3044   CIA UNUSED pc = PC;
3045   EXTRACT_FMT_RTE_VARS /* f-op1 f-r1 f-op2 f-r2 */
3046   EXTRACT_FMT_RTE_CODE
3047
3048 do {
3049   {
3050     UBI opval = OPRND (h_bsm_0);
3051     CPU (h_sm) = opval;
3052     TRACE_RESULT (current_cpu, "sm-0", 'x', opval);
3053   }
3054   {
3055     UBI opval = OPRND (h_bie_0);
3056     CPU (h_ie) = opval;
3057     TRACE_RESULT (current_cpu, "ie-0", 'x', opval);
3058   }
3059   {
3060     UBI opval = OPRND (h_bcond_0);
3061     CPU (h_cond) = opval;
3062     TRACE_RESULT (current_cpu, "condbit", 'x', opval);
3063   }
3064   {
3065     USI opval = ANDSI (OPRND (h_bpc_0), -4);
3066     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
3067     taken_p = 1;
3068     TRACE_RESULT (current_cpu, "pc", 'x', opval);
3069   }
3070 } while (0);
3071
3072   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3073
3074 #if WITH_PROFILE_MODEL_P
3075   if (PROFILE_MODEL_P (current_cpu))
3076     {
3077       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
3078     }
3079 #endif
3080
3081   return new_pc;
3082 #undef OPRND
3083 }
3084
3085 /* seth: seth $dr,$hash$hi16.  */
3086
3087 CIA
3088 SEM_FN_NAME (m32rx,seth) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3089 {
3090   insn_t insn = SEM_INSN (sem_arg);
3091 #define OPRND(f) par_exec->operands.fmt_seth.f
3092   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3093   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
3094   CIA UNUSED pc = PC;
3095   EXTRACT_FMT_SETH_VARS /* f-op1 f-r1 f-op2 f-r2 f-hi16 */
3096   EXTRACT_FMT_SETH_CODE
3097
3098   {
3099     SI opval = SLLSI (OPRND (hi16), 16);
3100     CPU (h_gr[f_r1]) = opval;
3101     TRACE_RESULT (current_cpu, "dr", 'x', opval);
3102   }
3103
3104   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3105
3106 #if WITH_PROFILE_MODEL_P
3107   if (PROFILE_MODEL_P (current_cpu))
3108     {
3109       m32rx_model_mark_set_h_gr (current_cpu, abuf);
3110       m32rx_model_profile_insn (current_cpu, abuf);
3111     }
3112 #endif
3113
3114   return new_pc;
3115 #undef OPRND
3116 }
3117
3118 /* sll: sll $dr,$sr.  */
3119
3120 CIA
3121 SEM_FN_NAME (m32rx,sll) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3122 {
3123   insn_t insn = SEM_INSN (sem_arg);
3124 #define OPRND(f) par_exec->operands.fmt_add.f
3125   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3126   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
3127   CIA UNUSED pc = PC;
3128   EXTRACT_FMT_ADD_VARS /* f-op1 f-r1 f-op2 f-r2 */
3129   EXTRACT_FMT_ADD_CODE
3130
3131   {
3132     SI opval = SLLSI (OPRND (dr), ANDSI (OPRND (sr), 31));
3133     CPU (h_gr[f_r1]) = opval;
3134     TRACE_RESULT (current_cpu, "dr", 'x', opval);
3135   }
3136
3137   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3138
3139 #if WITH_PROFILE_MODEL_P
3140   if (PROFILE_MODEL_P (current_cpu))
3141     {
3142       m32rx_model_mark_get_h_gr (current_cpu, abuf);
3143       m32rx_model_mark_set_h_gr (current_cpu, abuf);
3144       m32rx_model_profile_insn (current_cpu, abuf);
3145     }
3146 #endif
3147
3148   return new_pc;
3149 #undef OPRND
3150 }
3151
3152 /* sll3: sll3 $dr,$sr,$simm16.  */
3153
3154 CIA
3155 SEM_FN_NAME (m32rx,sll3) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3156 {
3157   insn_t insn = SEM_INSN (sem_arg);
3158 #define OPRND(f) par_exec->operands.fmt_sll3.f
3159   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3160   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
3161   CIA UNUSED pc = PC;
3162   EXTRACT_FMT_SLL3_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
3163   EXTRACT_FMT_SLL3_CODE
3164
3165   {
3166     SI opval = SLLSI (OPRND (sr), ANDSI (OPRND (simm16), 31));
3167     CPU (h_gr[f_r1]) = opval;
3168     TRACE_RESULT (current_cpu, "dr", 'x', opval);
3169   }
3170
3171   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3172
3173 #if WITH_PROFILE_MODEL_P
3174   if (PROFILE_MODEL_P (current_cpu))
3175     {
3176       m32rx_model_mark_get_h_gr (current_cpu, abuf);
3177       m32rx_model_mark_set_h_gr (current_cpu, abuf);
3178       m32rx_model_profile_insn (current_cpu, abuf);
3179     }
3180 #endif
3181
3182   return new_pc;
3183 #undef OPRND
3184 }
3185
3186 /* slli: slli $dr,$uimm5.  */
3187
3188 CIA
3189 SEM_FN_NAME (m32rx,slli) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3190 {
3191   insn_t insn = SEM_INSN (sem_arg);
3192 #define OPRND(f) par_exec->operands.fmt_slli.f
3193   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3194   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
3195   CIA UNUSED pc = PC;
3196   EXTRACT_FMT_SLLI_VARS /* f-op1 f-r1 f-shift-op2 f-uimm5 */
3197   EXTRACT_FMT_SLLI_CODE
3198
3199   {
3200     SI opval = SLLSI (OPRND (dr), OPRND (uimm5));
3201     CPU (h_gr[f_r1]) = opval;
3202     TRACE_RESULT (current_cpu, "dr", 'x', opval);
3203   }
3204
3205   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3206
3207 #if WITH_PROFILE_MODEL_P
3208   if (PROFILE_MODEL_P (current_cpu))
3209     {
3210       m32rx_model_mark_get_h_gr (current_cpu, abuf);
3211       m32rx_model_mark_set_h_gr (current_cpu, abuf);
3212       m32rx_model_profile_insn (current_cpu, abuf);
3213     }
3214 #endif
3215
3216   return new_pc;
3217 #undef OPRND
3218 }
3219
3220 /* sra: sra $dr,$sr.  */
3221
3222 CIA
3223 SEM_FN_NAME (m32rx,sra) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3224 {
3225   insn_t insn = SEM_INSN (sem_arg);
3226 #define OPRND(f) par_exec->operands.fmt_add.f
3227   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3228   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
3229   CIA UNUSED pc = PC;
3230   EXTRACT_FMT_ADD_VARS /* f-op1 f-r1 f-op2 f-r2 */
3231   EXTRACT_FMT_ADD_CODE
3232
3233   {
3234     SI opval = SRASI (OPRND (dr), ANDSI (OPRND (sr), 31));
3235     CPU (h_gr[f_r1]) = opval;
3236     TRACE_RESULT (current_cpu, "dr", 'x', opval);
3237   }
3238
3239   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3240
3241 #if WITH_PROFILE_MODEL_P
3242   if (PROFILE_MODEL_P (current_cpu))
3243     {
3244       m32rx_model_mark_get_h_gr (current_cpu, abuf);
3245       m32rx_model_mark_set_h_gr (current_cpu, abuf);
3246       m32rx_model_profile_insn (current_cpu, abuf);
3247     }
3248 #endif
3249
3250   return new_pc;
3251 #undef OPRND
3252 }
3253
3254 /* sra3: sra3 $dr,$sr,$simm16.  */
3255
3256 CIA
3257 SEM_FN_NAME (m32rx,sra3) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3258 {
3259   insn_t insn = SEM_INSN (sem_arg);
3260 #define OPRND(f) par_exec->operands.fmt_sll3.f
3261   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3262   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
3263   CIA UNUSED pc = PC;
3264   EXTRACT_FMT_SLL3_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
3265   EXTRACT_FMT_SLL3_CODE
3266
3267   {
3268     SI opval = SRASI (OPRND (sr), ANDSI (OPRND (simm16), 31));
3269     CPU (h_gr[f_r1]) = opval;
3270     TRACE_RESULT (current_cpu, "dr", 'x', opval);
3271   }
3272
3273   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3274
3275 #if WITH_PROFILE_MODEL_P
3276   if (PROFILE_MODEL_P (current_cpu))
3277     {
3278       m32rx_model_mark_get_h_gr (current_cpu, abuf);
3279       m32rx_model_mark_set_h_gr (current_cpu, abuf);
3280       m32rx_model_profile_insn (current_cpu, abuf);
3281     }
3282 #endif
3283
3284   return new_pc;
3285 #undef OPRND
3286 }
3287
3288 /* srai: srai $dr,$uimm5.  */
3289
3290 CIA
3291 SEM_FN_NAME (m32rx,srai) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3292 {
3293   insn_t insn = SEM_INSN (sem_arg);
3294 #define OPRND(f) par_exec->operands.fmt_slli.f
3295   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3296   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
3297   CIA UNUSED pc = PC;
3298   EXTRACT_FMT_SLLI_VARS /* f-op1 f-r1 f-shift-op2 f-uimm5 */
3299   EXTRACT_FMT_SLLI_CODE
3300
3301   {
3302     SI opval = SRASI (OPRND (dr), OPRND (uimm5));
3303     CPU (h_gr[f_r1]) = opval;
3304     TRACE_RESULT (current_cpu, "dr", 'x', opval);
3305   }
3306
3307   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3308
3309 #if WITH_PROFILE_MODEL_P
3310   if (PROFILE_MODEL_P (current_cpu))
3311     {
3312       m32rx_model_mark_get_h_gr (current_cpu, abuf);
3313       m32rx_model_mark_set_h_gr (current_cpu, abuf);
3314       m32rx_model_profile_insn (current_cpu, abuf);
3315     }
3316 #endif
3317
3318   return new_pc;
3319 #undef OPRND
3320 }
3321
3322 /* srl: srl $dr,$sr.  */
3323
3324 CIA
3325 SEM_FN_NAME (m32rx,srl) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3326 {
3327   insn_t insn = SEM_INSN (sem_arg);
3328 #define OPRND(f) par_exec->operands.fmt_add.f
3329   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3330   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
3331   CIA UNUSED pc = PC;
3332   EXTRACT_FMT_ADD_VARS /* f-op1 f-r1 f-op2 f-r2 */
3333   EXTRACT_FMT_ADD_CODE
3334
3335   {
3336     SI opval = SRLSI (OPRND (dr), ANDSI (OPRND (sr), 31));
3337     CPU (h_gr[f_r1]) = opval;
3338     TRACE_RESULT (current_cpu, "dr", 'x', opval);
3339   }
3340
3341   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3342
3343 #if WITH_PROFILE_MODEL_P
3344   if (PROFILE_MODEL_P (current_cpu))
3345     {
3346       m32rx_model_mark_get_h_gr (current_cpu, abuf);
3347       m32rx_model_mark_set_h_gr (current_cpu, abuf);
3348       m32rx_model_profile_insn (current_cpu, abuf);
3349     }
3350 #endif
3351
3352   return new_pc;
3353 #undef OPRND
3354 }
3355
3356 /* srl3: srl3 $dr,$sr,$simm16.  */
3357
3358 CIA
3359 SEM_FN_NAME (m32rx,srl3) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3360 {
3361   insn_t insn = SEM_INSN (sem_arg);
3362 #define OPRND(f) par_exec->operands.fmt_sll3.f
3363   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3364   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
3365   CIA UNUSED pc = PC;
3366   EXTRACT_FMT_SLL3_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
3367   EXTRACT_FMT_SLL3_CODE
3368
3369   {
3370     SI opval = SRLSI (OPRND (sr), ANDSI (OPRND (simm16), 31));
3371     CPU (h_gr[f_r1]) = opval;
3372     TRACE_RESULT (current_cpu, "dr", 'x', opval);
3373   }
3374
3375   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3376
3377 #if WITH_PROFILE_MODEL_P
3378   if (PROFILE_MODEL_P (current_cpu))
3379     {
3380       m32rx_model_mark_get_h_gr (current_cpu, abuf);
3381       m32rx_model_mark_set_h_gr (current_cpu, abuf);
3382       m32rx_model_profile_insn (current_cpu, abuf);
3383     }
3384 #endif
3385
3386   return new_pc;
3387 #undef OPRND
3388 }
3389
3390 /* srli: srli $dr,$uimm5.  */
3391
3392 CIA
3393 SEM_FN_NAME (m32rx,srli) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3394 {
3395   insn_t insn = SEM_INSN (sem_arg);
3396 #define OPRND(f) par_exec->operands.fmt_slli.f
3397   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3398   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
3399   CIA UNUSED pc = PC;
3400   EXTRACT_FMT_SLLI_VARS /* f-op1 f-r1 f-shift-op2 f-uimm5 */
3401   EXTRACT_FMT_SLLI_CODE
3402
3403   {
3404     SI opval = SRLSI (OPRND (dr), OPRND (uimm5));
3405     CPU (h_gr[f_r1]) = opval;
3406     TRACE_RESULT (current_cpu, "dr", 'x', opval);
3407   }
3408
3409   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3410
3411 #if WITH_PROFILE_MODEL_P
3412   if (PROFILE_MODEL_P (current_cpu))
3413     {
3414       m32rx_model_mark_get_h_gr (current_cpu, abuf);
3415       m32rx_model_mark_set_h_gr (current_cpu, abuf);
3416       m32rx_model_profile_insn (current_cpu, abuf);
3417     }
3418 #endif
3419
3420   return new_pc;
3421 #undef OPRND
3422 }
3423
3424 /* st: st $src1,@$src2.  */
3425
3426 CIA
3427 SEM_FN_NAME (m32rx,st) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3428 {
3429   insn_t insn = SEM_INSN (sem_arg);
3430 #define OPRND(f) par_exec->operands.fmt_st.f
3431   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3432   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
3433   CIA UNUSED pc = PC;
3434   EXTRACT_FMT_ST_VARS /* f-op1 f-r1 f-op2 f-r2 */
3435   EXTRACT_FMT_ST_CODE
3436
3437   {
3438     SI opval = OPRND (src1);
3439     SETMEMSI (current_cpu, OPRND (src2), opval);
3440     TRACE_RESULT (current_cpu, "memory", 'x', opval);
3441   }
3442
3443   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3444
3445 #if WITH_PROFILE_MODEL_P
3446   if (PROFILE_MODEL_P (current_cpu))
3447     {
3448       m32rx_model_mark_get_h_gr (current_cpu, abuf);
3449       m32rx_model_profile_insn (current_cpu, abuf);
3450     }
3451 #endif
3452
3453   return new_pc;
3454 #undef OPRND
3455 }
3456
3457 /* st-d: st $src1,@($slo16,$src2).  */
3458
3459 CIA
3460 SEM_FN_NAME (m32rx,st_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3461 {
3462   insn_t insn = SEM_INSN (sem_arg);
3463 #define OPRND(f) par_exec->operands.fmt_st_d.f
3464   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3465   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
3466   CIA UNUSED pc = PC;
3467   EXTRACT_FMT_ST_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
3468   EXTRACT_FMT_ST_D_CODE
3469
3470   {
3471     SI opval = OPRND (src1);
3472     SETMEMSI (current_cpu, ADDSI (OPRND (src2), OPRND (slo16)), opval);
3473     TRACE_RESULT (current_cpu, "memory", 'x', opval);
3474   }
3475
3476   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3477
3478 #if WITH_PROFILE_MODEL_P
3479   if (PROFILE_MODEL_P (current_cpu))
3480     {
3481       m32rx_model_mark_get_h_gr (current_cpu, abuf);
3482       m32rx_model_profile_insn (current_cpu, abuf);
3483     }
3484 #endif
3485
3486   return new_pc;
3487 #undef OPRND
3488 }
3489
3490 /* stb: stb $src1,@$src2.  */
3491
3492 CIA
3493 SEM_FN_NAME (m32rx,stb) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3494 {
3495   insn_t insn = SEM_INSN (sem_arg);
3496 #define OPRND(f) par_exec->operands.fmt_stb.f
3497   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3498   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
3499   CIA UNUSED pc = PC;
3500   EXTRACT_FMT_STB_VARS /* f-op1 f-r1 f-op2 f-r2 */
3501   EXTRACT_FMT_STB_CODE
3502
3503   {
3504     QI opval = OPRND (src1);
3505     SETMEMQI (current_cpu, OPRND (src2), opval);
3506     TRACE_RESULT (current_cpu, "memory", 'x', opval);
3507   }
3508
3509   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3510
3511 #if WITH_PROFILE_MODEL_P
3512   if (PROFILE_MODEL_P (current_cpu))
3513     {
3514       m32rx_model_mark_get_h_gr (current_cpu, abuf);
3515       m32rx_model_profile_insn (current_cpu, abuf);
3516     }
3517 #endif
3518
3519   return new_pc;
3520 #undef OPRND
3521 }
3522
3523 /* stb-d: stb $src1,@($slo16,$src2).  */
3524
3525 CIA
3526 SEM_FN_NAME (m32rx,stb_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3527 {
3528   insn_t insn = SEM_INSN (sem_arg);
3529 #define OPRND(f) par_exec->operands.fmt_stb_d.f
3530   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3531   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
3532   CIA UNUSED pc = PC;
3533   EXTRACT_FMT_STB_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
3534   EXTRACT_FMT_STB_D_CODE
3535
3536   {
3537     QI opval = OPRND (src1);
3538     SETMEMQI (current_cpu, ADDSI (OPRND (src2), OPRND (slo16)), opval);
3539     TRACE_RESULT (current_cpu, "memory", 'x', opval);
3540   }
3541
3542   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3543
3544 #if WITH_PROFILE_MODEL_P
3545   if (PROFILE_MODEL_P (current_cpu))
3546     {
3547       m32rx_model_mark_get_h_gr (current_cpu, abuf);
3548       m32rx_model_profile_insn (current_cpu, abuf);
3549     }
3550 #endif
3551
3552   return new_pc;
3553 #undef OPRND
3554 }
3555
3556 /* sth: sth $src1,@$src2.  */
3557
3558 CIA
3559 SEM_FN_NAME (m32rx,sth) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3560 {
3561   insn_t insn = SEM_INSN (sem_arg);
3562 #define OPRND(f) par_exec->operands.fmt_sth.f
3563   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3564   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
3565   CIA UNUSED pc = PC;
3566   EXTRACT_FMT_STH_VARS /* f-op1 f-r1 f-op2 f-r2 */
3567   EXTRACT_FMT_STH_CODE
3568
3569   {
3570     HI opval = OPRND (src1);
3571     SETMEMHI (current_cpu, OPRND (src2), opval);
3572     TRACE_RESULT (current_cpu, "memory", 'x', opval);
3573   }
3574
3575   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3576
3577 #if WITH_PROFILE_MODEL_P
3578   if (PROFILE_MODEL_P (current_cpu))
3579     {
3580       m32rx_model_mark_get_h_gr (current_cpu, abuf);
3581       m32rx_model_profile_insn (current_cpu, abuf);
3582     }
3583 #endif
3584
3585   return new_pc;
3586 #undef OPRND
3587 }
3588
3589 /* sth-d: sth $src1,@($slo16,$src2).  */
3590
3591 CIA
3592 SEM_FN_NAME (m32rx,sth_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3593 {
3594   insn_t insn = SEM_INSN (sem_arg);
3595 #define OPRND(f) par_exec->operands.fmt_sth_d.f
3596   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3597   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
3598   CIA UNUSED pc = PC;
3599   EXTRACT_FMT_STH_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
3600   EXTRACT_FMT_STH_D_CODE
3601
3602   {
3603     HI opval = OPRND (src1);
3604     SETMEMHI (current_cpu, ADDSI (OPRND (src2), OPRND (slo16)), opval);
3605     TRACE_RESULT (current_cpu, "memory", 'x', opval);
3606   }
3607
3608   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3609
3610 #if WITH_PROFILE_MODEL_P
3611   if (PROFILE_MODEL_P (current_cpu))
3612     {
3613       m32rx_model_mark_get_h_gr (current_cpu, abuf);
3614       m32rx_model_profile_insn (current_cpu, abuf);
3615     }
3616 #endif
3617
3618   return new_pc;
3619 #undef OPRND
3620 }
3621
3622 /* st-plus: st $src1,@+$src2.  */
3623
3624 CIA
3625 SEM_FN_NAME (m32rx,st_plus) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3626 {
3627   insn_t insn = SEM_INSN (sem_arg);
3628 #define OPRND(f) par_exec->operands.fmt_st_plus.f
3629   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3630   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
3631   CIA UNUSED pc = PC;
3632   EXTRACT_FMT_ST_PLUS_VARS /* f-op1 f-r1 f-op2 f-r2 */
3633   EXTRACT_FMT_ST_PLUS_CODE
3634
3635 do {
3636   SI tmp_new_src2;
3637   tmp_new_src2 = ADDSI (OPRND (src2), 4);
3638   {
3639     SI opval = OPRND (src1);
3640     SETMEMSI (current_cpu, tmp_new_src2, opval);
3641     TRACE_RESULT (current_cpu, "memory", 'x', opval);
3642   }
3643   {
3644     SI opval = tmp_new_src2;
3645     CPU (h_gr[f_r2]) = opval;
3646     TRACE_RESULT (current_cpu, "src2", 'x', opval);
3647   }
3648 } while (0);
3649
3650   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3651
3652 #if WITH_PROFILE_MODEL_P
3653   if (PROFILE_MODEL_P (current_cpu))
3654     {
3655       m32rx_model_mark_get_h_gr (current_cpu, abuf);
3656       m32rx_model_mark_set_h_gr (current_cpu, abuf);
3657       m32rx_model_profile_insn (current_cpu, abuf);
3658     }
3659 #endif
3660
3661   return new_pc;
3662 #undef OPRND
3663 }
3664
3665 /* st-minus: st $src1,@-$src2.  */
3666
3667 CIA
3668 SEM_FN_NAME (m32rx,st_minus) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3669 {
3670   insn_t insn = SEM_INSN (sem_arg);
3671 #define OPRND(f) par_exec->operands.fmt_st_plus.f
3672   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3673   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
3674   CIA UNUSED pc = PC;
3675   EXTRACT_FMT_ST_PLUS_VARS /* f-op1 f-r1 f-op2 f-r2 */
3676   EXTRACT_FMT_ST_PLUS_CODE
3677
3678 do {
3679   SI tmp_new_src2;
3680   tmp_new_src2 = SUBSI (OPRND (src2), 4);
3681   {
3682     SI opval = OPRND (src1);
3683     SETMEMSI (current_cpu, tmp_new_src2, opval);
3684     TRACE_RESULT (current_cpu, "memory", 'x', opval);
3685   }
3686   {
3687     SI opval = tmp_new_src2;
3688     CPU (h_gr[f_r2]) = opval;
3689     TRACE_RESULT (current_cpu, "src2", 'x', opval);
3690   }
3691 } while (0);
3692
3693   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3694
3695 #if WITH_PROFILE_MODEL_P
3696   if (PROFILE_MODEL_P (current_cpu))
3697     {
3698       m32rx_model_mark_get_h_gr (current_cpu, abuf);
3699       m32rx_model_mark_set_h_gr (current_cpu, abuf);
3700       m32rx_model_profile_insn (current_cpu, abuf);
3701     }
3702 #endif
3703
3704   return new_pc;
3705 #undef OPRND
3706 }
3707
3708 /* sub: sub $dr,$sr.  */
3709
3710 CIA
3711 SEM_FN_NAME (m32rx,sub) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3712 {
3713   insn_t insn = SEM_INSN (sem_arg);
3714 #define OPRND(f) par_exec->operands.fmt_add.f
3715   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3716   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
3717   CIA UNUSED pc = PC;
3718   EXTRACT_FMT_ADD_VARS /* f-op1 f-r1 f-op2 f-r2 */
3719   EXTRACT_FMT_ADD_CODE
3720
3721   {
3722     SI opval = SUBSI (OPRND (dr), OPRND (sr));
3723     CPU (h_gr[f_r1]) = opval;
3724     TRACE_RESULT (current_cpu, "dr", 'x', opval);
3725   }
3726
3727   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3728
3729 #if WITH_PROFILE_MODEL_P
3730   if (PROFILE_MODEL_P (current_cpu))
3731     {
3732       m32rx_model_mark_get_h_gr (current_cpu, abuf);
3733       m32rx_model_mark_set_h_gr (current_cpu, abuf);
3734       m32rx_model_profile_insn (current_cpu, abuf);
3735     }
3736 #endif
3737
3738   return new_pc;
3739 #undef OPRND
3740 }
3741
3742 /* subv: subv $dr,$sr.  */
3743
3744 CIA
3745 SEM_FN_NAME (m32rx,subv) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3746 {
3747   insn_t insn = SEM_INSN (sem_arg);
3748 #define OPRND(f) par_exec->operands.fmt_addv.f
3749   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3750   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
3751   CIA UNUSED pc = PC;
3752   EXTRACT_FMT_ADDV_VARS /* f-op1 f-r1 f-op2 f-r2 */
3753   EXTRACT_FMT_ADDV_CODE
3754
3755 do {
3756   UBI temp1;SI temp0;
3757   temp0 = SUBSI (OPRND (dr), OPRND (sr));
3758   temp1 = SUBOFSI (OPRND (dr), OPRND (sr), 0);
3759   {
3760     SI opval = temp0;
3761     CPU (h_gr[f_r1]) = opval;
3762     TRACE_RESULT (current_cpu, "dr", 'x', opval);
3763   }
3764   {
3765     UBI opval = temp1;
3766     CPU (h_cond) = opval;
3767     TRACE_RESULT (current_cpu, "condbit", 'x', opval);
3768   }
3769 } while (0);
3770
3771   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3772
3773 #if WITH_PROFILE_MODEL_P
3774   if (PROFILE_MODEL_P (current_cpu))
3775     {
3776       m32rx_model_mark_get_h_gr (current_cpu, abuf);
3777       m32rx_model_mark_set_h_gr (current_cpu, abuf);
3778       m32rx_model_profile_insn (current_cpu, abuf);
3779     }
3780 #endif
3781
3782   return new_pc;
3783 #undef OPRND
3784 }
3785
3786 /* subx: subx $dr,$sr.  */
3787
3788 CIA
3789 SEM_FN_NAME (m32rx,subx) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3790 {
3791   insn_t insn = SEM_INSN (sem_arg);
3792 #define OPRND(f) par_exec->operands.fmt_addx.f
3793   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3794   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
3795   CIA UNUSED pc = PC;
3796   EXTRACT_FMT_ADDX_VARS /* f-op1 f-r1 f-op2 f-r2 */
3797   EXTRACT_FMT_ADDX_CODE
3798
3799 do {
3800   UBI temp1;SI temp0;
3801   temp0 = SUBCSI (OPRND (dr), OPRND (sr), OPRND (condbit));
3802   temp1 = SUBCFSI (OPRND (dr), OPRND (sr), OPRND (condbit));
3803   {
3804     SI opval = temp0;
3805     CPU (h_gr[f_r1]) = opval;
3806     TRACE_RESULT (current_cpu, "dr", 'x', opval);
3807   }
3808   {
3809     UBI opval = temp1;
3810     CPU (h_cond) = opval;
3811     TRACE_RESULT (current_cpu, "condbit", 'x', opval);
3812   }
3813 } while (0);
3814
3815   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3816
3817 #if WITH_PROFILE_MODEL_P
3818   if (PROFILE_MODEL_P (current_cpu))
3819     {
3820       m32rx_model_mark_get_h_gr (current_cpu, abuf);
3821       m32rx_model_mark_set_h_gr (current_cpu, abuf);
3822       m32rx_model_profile_insn (current_cpu, abuf);
3823     }
3824 #endif
3825
3826   return new_pc;
3827 #undef OPRND
3828 }
3829
3830 /* trap: trap $uimm4.  */
3831
3832 CIA
3833 SEM_FN_NAME (m32rx,trap) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3834 {
3835   insn_t insn = SEM_INSN (sem_arg);
3836 #define OPRND(f) par_exec->operands.fmt_trap.f
3837   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3838   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
3839   int taken_p = 0;
3840   CIA UNUSED pc = PC;
3841   EXTRACT_FMT_TRAP_VARS /* f-op1 f-r1 f-op2 f-uimm4 */
3842   EXTRACT_FMT_TRAP_CODE
3843
3844 do {
3845   {
3846     USI opval = ADDSI (OPRND (pc), 4);
3847     m32rx_h_cr_set (current_cpu, ((HOSTUINT) 6), opval);
3848     TRACE_RESULT (current_cpu, "cr-6", 'x', opval);
3849   }
3850   {
3851     USI opval = ANDSI (SLLSI (OPRND (h_cr_0), 8), 65408);
3852     m32rx_h_cr_set (current_cpu, ((HOSTUINT) 0), opval);
3853     TRACE_RESULT (current_cpu, "cr-0", 'x', opval);
3854   }
3855   {
3856     SI opval = m32r_trap (current_cpu, OPRND (uimm4));
3857     BRANCH_NEW_PC (new_pc, SEM_BRANCH_VIA_ADDR (sem_arg, opval));
3858     taken_p = 1;
3859     TRACE_RESULT (current_cpu, "pc", 'x', opval);
3860   }
3861 } while (0);
3862
3863   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3864
3865 #if WITH_PROFILE_MODEL_P
3866   if (PROFILE_MODEL_P (current_cpu))
3867     {
3868       m32rx_model_profile_cti_insn (current_cpu, abuf, taken_p);
3869     }
3870 #endif
3871
3872   return new_pc;
3873 #undef OPRND
3874 }
3875
3876 /* unlock: unlock $src1,@$src2.  */
3877
3878 CIA
3879 SEM_FN_NAME (m32rx,unlock) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3880 {
3881   insn_t insn = SEM_INSN (sem_arg);
3882 #define OPRND(f) par_exec->operands.fmt_unlock.f
3883   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3884   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
3885   CIA UNUSED pc = PC;
3886   EXTRACT_FMT_UNLOCK_VARS /* f-op1 f-r1 f-op2 f-r2 */
3887   EXTRACT_FMT_UNLOCK_CODE
3888
3889 do {
3890 if (OPRND (h_lock_0)) {
3891   {
3892     SI opval = OPRND (src1);
3893     SETMEMSI (current_cpu, OPRND (src2), opval);
3894     TRACE_RESULT (current_cpu, "memory", 'x', opval);
3895   }
3896 }
3897   {
3898     UBI opval = 0;
3899     CPU (h_lock) = opval;
3900     TRACE_RESULT (current_cpu, "lock-0", 'x', opval);
3901   }
3902 } while (0);
3903
3904   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3905
3906 #if WITH_PROFILE_MODEL_P
3907   if (PROFILE_MODEL_P (current_cpu))
3908     {
3909       m32rx_model_mark_get_h_gr (current_cpu, abuf);
3910       m32rx_model_profile_insn (current_cpu, abuf);
3911     }
3912 #endif
3913
3914   return new_pc;
3915 #undef OPRND
3916 }
3917
3918 /* satb: satb $dr,$sr.  */
3919
3920 CIA
3921 SEM_FN_NAME (m32rx,satb) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3922 {
3923   insn_t insn = SEM_INSN (sem_arg);
3924 #define OPRND(f) par_exec->operands.fmt_satb.f
3925   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3926   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
3927   CIA UNUSED pc = PC;
3928   EXTRACT_FMT_SATB_VARS /* f-op1 f-r1 f-op2 f-r2 f-uimm16 */
3929   EXTRACT_FMT_SATB_CODE
3930
3931   {
3932     SI opval = (GESI (OPRND (sr), 127)) ? (127) : (LESI (OPRND (sr), -128)) ? (-128) : (OPRND (sr));
3933     CPU (h_gr[f_r1]) = opval;
3934     TRACE_RESULT (current_cpu, "dr", 'x', opval);
3935   }
3936
3937   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3938
3939 #if WITH_PROFILE_MODEL_P
3940   if (PROFILE_MODEL_P (current_cpu))
3941     {
3942       m32rx_model_mark_get_h_gr (current_cpu, abuf);
3943       m32rx_model_mark_set_h_gr (current_cpu, abuf);
3944       m32rx_model_profile_insn (current_cpu, abuf);
3945     }
3946 #endif
3947
3948   return new_pc;
3949 #undef OPRND
3950 }
3951
3952 /* sath: sath $dr,$sr.  */
3953
3954 CIA
3955 SEM_FN_NAME (m32rx,sath) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3956 {
3957   insn_t insn = SEM_INSN (sem_arg);
3958 #define OPRND(f) par_exec->operands.fmt_satb.f
3959   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3960   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
3961   CIA UNUSED pc = PC;
3962   EXTRACT_FMT_SATB_VARS /* f-op1 f-r1 f-op2 f-r2 f-uimm16 */
3963   EXTRACT_FMT_SATB_CODE
3964
3965   {
3966     SI opval = (GESI (OPRND (sr), 32767)) ? (32767) : (LESI (OPRND (sr), -32768)) ? (-32768) : (OPRND (sr));
3967     CPU (h_gr[f_r1]) = opval;
3968     TRACE_RESULT (current_cpu, "dr", 'x', opval);
3969   }
3970
3971   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
3972
3973 #if WITH_PROFILE_MODEL_P
3974   if (PROFILE_MODEL_P (current_cpu))
3975     {
3976       m32rx_model_mark_get_h_gr (current_cpu, abuf);
3977       m32rx_model_mark_set_h_gr (current_cpu, abuf);
3978       m32rx_model_profile_insn (current_cpu, abuf);
3979     }
3980 #endif
3981
3982   return new_pc;
3983 #undef OPRND
3984 }
3985
3986 /* sat: sat $dr,$sr.  */
3987
3988 CIA
3989 SEM_FN_NAME (m32rx,sat) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
3990 {
3991   insn_t insn = SEM_INSN (sem_arg);
3992 #define OPRND(f) par_exec->operands.fmt_sat.f
3993   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3994   CIA new_pc = SEM_NEXT_PC (sem_arg, 4);
3995   CIA UNUSED pc = PC;
3996   EXTRACT_FMT_SAT_VARS /* f-op1 f-r1 f-op2 f-r2 f-uimm16 */
3997   EXTRACT_FMT_SAT_CODE
3998
3999   {
4000     SI opval = ((OPRND (condbit)) ? (((LTSI (OPRND (sr), 0)) ? (2147483647) : (0x80000000))) : (OPRND (sr)));
4001     CPU (h_gr[f_r1]) = opval;
4002     TRACE_RESULT (current_cpu, "dr", 'x', opval);
4003   }
4004
4005   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
4006
4007 #if WITH_PROFILE_MODEL_P
4008   if (PROFILE_MODEL_P (current_cpu))
4009     {
4010       m32rx_model_mark_get_h_gr (current_cpu, abuf);
4011       m32rx_model_mark_set_h_gr (current_cpu, abuf);
4012       m32rx_model_profile_insn (current_cpu, abuf);
4013     }
4014 #endif
4015
4016   return new_pc;
4017 #undef OPRND
4018 }
4019
4020 /* pcmpbz: pcmpbz $src2.  */
4021
4022 CIA
4023 SEM_FN_NAME (m32rx,pcmpbz) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
4024 {
4025   insn_t insn = SEM_INSN (sem_arg);
4026 #define OPRND(f) par_exec->operands.fmt_cmpz.f
4027   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4028   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
4029   CIA UNUSED pc = PC;
4030   EXTRACT_FMT_CMPZ_VARS /* f-op1 f-r1 f-op2 f-r2 */
4031   EXTRACT_FMT_CMPZ_CODE
4032
4033   {
4034     UBI opval = (EQSI (ANDSI (OPRND (src2), 255), 0)) ? (1) : (EQSI (ANDSI (OPRND (src2), 65280), 0)) ? (1) : (EQSI (ANDSI (OPRND (src2), 16711680), 0)) ? (1) : (EQSI (ANDSI (OPRND (src2), 0xff000000), 0)) ? (1) : (0);
4035     CPU (h_cond) = opval;
4036     TRACE_RESULT (current_cpu, "condbit", 'x', opval);
4037   }
4038
4039   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
4040
4041 #if WITH_PROFILE_MODEL_P
4042   if (PROFILE_MODEL_P (current_cpu))
4043     {
4044       m32rx_model_mark_get_h_gr (current_cpu, abuf);
4045       m32rx_model_profile_insn (current_cpu, abuf);
4046     }
4047 #endif
4048
4049   return new_pc;
4050 #undef OPRND
4051 }
4052
4053 /* sadd: sadd.  */
4054
4055 CIA
4056 SEM_FN_NAME (m32rx,sadd) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
4057 {
4058   insn_t insn = SEM_INSN (sem_arg);
4059 #define OPRND(f) par_exec->operands.fmt_sadd.f
4060   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4061   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
4062   CIA UNUSED pc = PC;
4063   EXTRACT_FMT_SADD_VARS /* f-op1 f-r1 f-op2 f-r2 */
4064   EXTRACT_FMT_SADD_CODE
4065
4066   {
4067     DI opval = ADDDI (SRADI (OPRND (h_accums_1), 16), OPRND (h_accums_0));
4068     m32rx_h_accums_set (current_cpu, ((HOSTUINT) 0), opval);
4069     TRACE_RESULT (current_cpu, "accums-0", 'D', opval);
4070   }
4071
4072   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
4073
4074 #if WITH_PROFILE_MODEL_P
4075   if (PROFILE_MODEL_P (current_cpu))
4076     {
4077       m32rx_model_profile_insn (current_cpu, abuf);
4078     }
4079 #endif
4080
4081   return new_pc;
4082 #undef OPRND
4083 }
4084
4085 /* macwu1: macwu1 $src1,$src2.  */
4086
4087 CIA
4088 SEM_FN_NAME (m32rx,macwu1) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
4089 {
4090   insn_t insn = SEM_INSN (sem_arg);
4091 #define OPRND(f) par_exec->operands.fmt_macwu1.f
4092   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4093   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
4094   CIA UNUSED pc = PC;
4095   EXTRACT_FMT_MACWU1_VARS /* f-op1 f-r1 f-op2 f-r2 */
4096   EXTRACT_FMT_MACWU1_CODE
4097
4098   {
4099     DI opval = SRADI (SLLDI (ADDDI (OPRND (h_accums_1), MULDI (EXTSIDI (OPRND (src1)), EXTSIDI (ANDSI (OPRND (src2), 65535)))), 8), 8);
4100     m32rx_h_accums_set (current_cpu, ((HOSTUINT) 1), opval);
4101     TRACE_RESULT (current_cpu, "accums-1", 'D', opval);
4102   }
4103
4104   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
4105
4106 #if WITH_PROFILE_MODEL_P
4107   if (PROFILE_MODEL_P (current_cpu))
4108     {
4109       m32rx_model_mark_get_h_gr (current_cpu, abuf);
4110       m32rx_model_profile_insn (current_cpu, abuf);
4111     }
4112 #endif
4113
4114   return new_pc;
4115 #undef OPRND
4116 }
4117
4118 /* msblo: msblo $src1,$src2.  */
4119
4120 CIA
4121 SEM_FN_NAME (m32rx,msblo) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
4122 {
4123   insn_t insn = SEM_INSN (sem_arg);
4124 #define OPRND(f) par_exec->operands.fmt_macwhi.f
4125   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4126   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
4127   CIA UNUSED pc = PC;
4128   EXTRACT_FMT_MACWHI_VARS /* f-op1 f-r1 f-op2 f-r2 */
4129   EXTRACT_FMT_MACWHI_CODE
4130
4131   {
4132     DI opval = SRADI (SLLDI (SUBDI (OPRND (accum), SRADI (SLLDI (MULDI (EXTHIDI (TRUNCSIHI (OPRND (src1))), EXTHIDI (TRUNCSIHI (OPRND (src2)))), 32), 16)), 8), 8);
4133     m32rx_h_accum_set (current_cpu, opval);
4134     TRACE_RESULT (current_cpu, "accum", 'D', opval);
4135   }
4136
4137   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
4138
4139 #if WITH_PROFILE_MODEL_P
4140   if (PROFILE_MODEL_P (current_cpu))
4141     {
4142       m32rx_model_mark_get_h_gr (current_cpu, abuf);
4143       m32rx_model_profile_insn (current_cpu, abuf);
4144     }
4145 #endif
4146
4147   return new_pc;
4148 #undef OPRND
4149 }
4150
4151 /* mulwu1: mulwu1 $src1,$src2.  */
4152
4153 CIA
4154 SEM_FN_NAME (m32rx,mulwu1) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
4155 {
4156   insn_t insn = SEM_INSN (sem_arg);
4157 #define OPRND(f) par_exec->operands.fmt_mulwu1.f
4158   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4159   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
4160   CIA UNUSED pc = PC;
4161   EXTRACT_FMT_MULWU1_VARS /* f-op1 f-r1 f-op2 f-r2 */
4162   EXTRACT_FMT_MULWU1_CODE
4163
4164   {
4165     DI opval = SRADI (SLLDI (MULDI (EXTSIDI (OPRND (src1)), EXTSIDI (ANDSI (OPRND (src2), 65535))), 16), 16);
4166     m32rx_h_accums_set (current_cpu, ((HOSTUINT) 1), opval);
4167     TRACE_RESULT (current_cpu, "accums-1", 'D', opval);
4168   }
4169
4170   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
4171
4172 #if WITH_PROFILE_MODEL_P
4173   if (PROFILE_MODEL_P (current_cpu))
4174     {
4175       m32rx_model_mark_get_h_gr (current_cpu, abuf);
4176       m32rx_model_profile_insn (current_cpu, abuf);
4177     }
4178 #endif
4179
4180   return new_pc;
4181 #undef OPRND
4182 }
4183
4184 /* maclh1: maclh1 $src1,$src2.  */
4185
4186 CIA
4187 SEM_FN_NAME (m32rx,maclh1) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
4188 {
4189   insn_t insn = SEM_INSN (sem_arg);
4190 #define OPRND(f) par_exec->operands.fmt_macwu1.f
4191   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4192   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
4193   CIA UNUSED pc = PC;
4194   EXTRACT_FMT_MACWU1_VARS /* f-op1 f-r1 f-op2 f-r2 */
4195   EXTRACT_FMT_MACWU1_CODE
4196
4197   {
4198     DI opval = SRADI (SLLDI (ADDDI (OPRND (h_accums_1), SLLDI (EXTSIDI (MULSI (EXTHISI (TRUNCSIHI (OPRND (src1))), SRASI (OPRND (src2), 16))), 16)), 8), 8);
4199     m32rx_h_accums_set (current_cpu, ((HOSTUINT) 1), opval);
4200     TRACE_RESULT (current_cpu, "accums-1", 'D', opval);
4201   }
4202
4203   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
4204
4205 #if WITH_PROFILE_MODEL_P
4206   if (PROFILE_MODEL_P (current_cpu))
4207     {
4208       m32rx_model_mark_get_h_gr (current_cpu, abuf);
4209       m32rx_model_profile_insn (current_cpu, abuf);
4210     }
4211 #endif
4212
4213   return new_pc;
4214 #undef OPRND
4215 }
4216
4217 /* sc: sc.  */
4218
4219 CIA
4220 SEM_FN_NAME (m32rx,sc) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
4221 {
4222   insn_t insn = SEM_INSN (sem_arg);
4223 #define OPRND(f) par_exec->operands.fmt_sc.f
4224   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4225   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
4226   CIA UNUSED pc = PC;
4227   EXTRACT_FMT_SC_VARS /* f-op1 f-r1 f-op2 f-r2 */
4228   EXTRACT_FMT_SC_CODE
4229
4230 if (OPRND (condbit)) {
4231 BRANCH_NEW_PC (new_pc, NEW_PC_SKIP);
4232 }
4233
4234   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
4235
4236 #if WITH_PROFILE_MODEL_P
4237   if (PROFILE_MODEL_P (current_cpu))
4238     {
4239       m32rx_model_profile_insn (current_cpu, abuf);
4240     }
4241 #endif
4242
4243   return new_pc;
4244 #undef OPRND
4245 }
4246
4247 /* snc: snc.  */
4248
4249 CIA
4250 SEM_FN_NAME (m32rx,snc) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
4251 {
4252   insn_t insn = SEM_INSN (sem_arg);
4253 #define OPRND(f) par_exec->operands.fmt_sc.f
4254   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4255   CIA new_pc = SEM_NEXT_PC (sem_arg, 2);
4256   CIA UNUSED pc = PC;
4257   EXTRACT_FMT_SC_VARS /* f-op1 f-r1 f-op2 f-r2 */
4258   EXTRACT_FMT_SC_CODE
4259
4260 if (NOTBI (OPRND (condbit))) {
4261 BRANCH_NEW_PC (new_pc, NEW_PC_SKIP);
4262 }
4263
4264   PROFILE_COUNT_INSN (current_cpu, 0, abuf->idesc->num);
4265
4266 #if WITH_PROFILE_MODEL_P
4267   if (PROFILE_MODEL_P (current_cpu))
4268     {
4269       m32rx_model_profile_insn (current_cpu, abuf);
4270     }
4271 #endif
4272
4273   return new_pc;
4274 #undef OPRND
4275 }
4276
4277 CIA
4278 SEM_FN_NAME (m32rx,illegal) (SIM_CPU *current_cpu, SEM_ARG sem_arg, PAREXEC *par_exec)
4279 {
4280   sim_engine_illegal_insn (current_cpu, NULL_CIA /*FIXME*/);
4281   return 0;
4282 }
4283
4284 #endif /* WANT_CPU */