sim/iq2000/sem.c

   1 /* Simulator instruction semantics for iq2000bf.
   2
   3 THIS FILE IS MACHINE GENERATED WITH CGEN.
   4
   5 Copyright 1996-2010 Free Software Foundation, Inc.
   6
   7 This file is part of the GNU simulators.
   8
   9    This file 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 3, or (at your option)
  12    any later version.
  13
  14    It is distributed in the hope that it will be useful, but WITHOUT
  15    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  16    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  17    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    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
  22
  23 */
  24
  25 #define WANT_CPU iq2000bf
  26 #define WANT_CPU_IQ2000BF
  27
  28 #include "sim-main.h"
  29 #include "cgen-mem.h"
  30 #include "cgen-ops.h"
  31
  32 #undef GET_ATTR
  33 #define GET_ATTR(cpu, num, attr) CGEN_ATTR_VALUE (NULL, abuf->idesc->attrs, CGEN_INSN_##attr)
  34
  35 /* This is used so that we can compile two copies of the semantic code,
  36    one with full feature support and one without that runs fast(er).
  37    FAST_P, when desired, is defined on the command line, -DFAST_P=1.  */
  38 #if FAST_P
  39 #define SEM_FN_NAME(cpu,fn) XCONCAT3 (cpu,_semf_,fn)
  40 #undef TRACE_RESULT
  41 #define TRACE_RESULT(cpu, abuf, name, type, val)
  42 #else
  43 #define SEM_FN_NAME(cpu,fn) XCONCAT3 (cpu,_sem_,fn)
  44 #endif
  45
  46 /* x-invalid: --invalid-- */
  47
  48 static SEM_PC
  49 SEM_FN_NAME (iq2000bf,x_invalid) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
  50 {
  51 #define FLD(f) abuf->fields.sfmt_empty.f
  52   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
  53   int UNUSED written = 0;
  54   IADDR UNUSED pc = abuf->addr;
  55   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
  56
  57   {
  58     /* Update the recorded pc in the cpu state struct.
  59        Only necessary for WITH_SCACHE case, but to avoid the
  60        conditional compilation ....  */
  61     SET_H_PC (pc);
  62     /* Virtual insns have zero size.  Overwrite vpc with address of next insn
  63        using the default-insn-bitsize spec.  When executing insns in parallel
  64        we may want to queue the fault and continue execution.  */
  65     vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
  66     vpc = sim_engine_invalid_insn (current_cpu, pc, vpc);
  67   }
  68
  69   return vpc;
  70 #undef FLD
  71 }
  72
  73 /* x-after: --after-- */
  74
  75 static SEM_PC
  76 SEM_FN_NAME (iq2000bf,x_after) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
  77 {
  78 #define FLD(f) abuf->fields.sfmt_empty.f
  79   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
  80   int UNUSED written = 0;
  81   IADDR UNUSED pc = abuf->addr;
  82   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
  83
  84   {
  85 #if WITH_SCACHE_PBB_IQ2000BF
  86     iq2000bf_pbb_after (current_cpu, sem_arg);
  87 #endif
  88   }
  89
  90   return vpc;
  91 #undef FLD
  92 }
  93
  94 /* x-before: --before-- */
  95
  96 static SEM_PC
  97 SEM_FN_NAME (iq2000bf,x_before) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
  98 {
  99 #define FLD(f) abuf->fields.sfmt_empty.f
 100   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 101   int UNUSED written = 0;
 102   IADDR UNUSED pc = abuf->addr;
 103   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
 104
 105   {
 106 #if WITH_SCACHE_PBB_IQ2000BF
 107     iq2000bf_pbb_before (current_cpu, sem_arg);
 108 #endif
 109   }
 110
 111   return vpc;
 112 #undef FLD
 113 }
 114
 115 /* x-cti-chain: --cti-chain-- */
 116
 117 static SEM_PC
 118 SEM_FN_NAME (iq2000bf,x_cti_chain) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 119 {
 120 #define FLD(f) abuf->fields.sfmt_empty.f
 121   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 122   int UNUSED written = 0;
 123   IADDR UNUSED pc = abuf->addr;
 124   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
 125
 126   {
 127 #if WITH_SCACHE_PBB_IQ2000BF
 128 #ifdef DEFINE_SWITCH
 129     vpc = iq2000bf_pbb_cti_chain (current_cpu, sem_arg,
 130                                pbb_br_type, pbb_br_npc);
 131     BREAK (sem);
 132 #else
 133     /* FIXME: Allow provision of explicit ifmt spec in insn spec.  */
 134     vpc = iq2000bf_pbb_cti_chain (current_cpu, sem_arg,
 135                                CPU_PBB_BR_TYPE (current_cpu),
 136                                CPU_PBB_BR_NPC (current_cpu));
 137 #endif
 138 #endif
 139   }
 140
 141   return vpc;
 142 #undef FLD
 143 }
 144
 145 /* x-chain: --chain-- */
 146
 147 static SEM_PC
 148 SEM_FN_NAME (iq2000bf,x_chain) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 149 {
 150 #define FLD(f) abuf->fields.sfmt_empty.f
 151   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 152   int UNUSED written = 0;
 153   IADDR UNUSED pc = abuf->addr;
 154   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
 155
 156   {
 157 #if WITH_SCACHE_PBB_IQ2000BF
 158     vpc = iq2000bf_pbb_chain (current_cpu, sem_arg);
 159 #ifdef DEFINE_SWITCH
 160     BREAK (sem);
 161 #endif
 162 #endif
 163   }
 164
 165   return vpc;
 166 #undef FLD
 167 }
 168
 169 /* x-begin: --begin-- */
 170
 171 static SEM_PC
 172 SEM_FN_NAME (iq2000bf,x_begin) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 173 {
 174 #define FLD(f) abuf->fields.sfmt_empty.f
 175   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 176   int UNUSED written = 0;
 177   IADDR UNUSED pc = abuf->addr;
 178   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
 179
 180   {
 181 #if WITH_SCACHE_PBB_IQ2000BF
 182 #if defined DEFINE_SWITCH || defined FAST_P
 183     /* In the switch case FAST_P is a constant, allowing several optimizations
 184        in any called inline functions.  */
 185     vpc = iq2000bf_pbb_begin (current_cpu, FAST_P);
 186 #else
 187 #if 0 /* cgen engine can't handle dynamic fast/full switching yet.  */
 188     vpc = iq2000bf_pbb_begin (current_cpu, STATE_RUN_FAST_P (CPU_STATE (current_cpu)));
 189 #else
 190     vpc = iq2000bf_pbb_begin (current_cpu, 0);
 191 #endif
 192 #endif
 193 #endif
 194   }
 195
 196   return vpc;
 197 #undef FLD
 198 }
 199
 200 /* add: add $rd,$rs,$rt */
 201
 202 static SEM_PC
 203 SEM_FN_NAME (iq2000bf,add) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 204 {
 205 #define FLD(f) abuf->fields.sfmt_mrgb.f
 206   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 207   int UNUSED written = 0;
 208   IADDR UNUSED pc = abuf->addr;
 209   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 210
 211   {
 212     SI opval = ADDSI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)));
 213     SET_H_GR (FLD (f_rd), opval);
 214     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 215   }
 216
 217   return vpc;
 218 #undef FLD
 219 }
 220
 221 /* addi: addi $rt,$rs,$lo16 */
 222
 223 static SEM_PC
 224 SEM_FN_NAME (iq2000bf,addi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 225 {
 226 #define FLD(f) abuf->fields.sfmt_addi.f
 227   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 228   int UNUSED written = 0;
 229   IADDR UNUSED pc = abuf->addr;
 230   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 231
 232   {
 233     SI opval = ADDSI (GET_H_GR (FLD (f_rs)), EXTHISI (TRUNCSIHI (FLD (f_imm))));
 234     SET_H_GR (FLD (f_rt), opval);
 235     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 236   }
 237
 238   return vpc;
 239 #undef FLD
 240 }
 241
 242 /* addiu: addiu $rt,$rs,$lo16 */
 243
 244 static SEM_PC
 245 SEM_FN_NAME (iq2000bf,addiu) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 246 {
 247 #define FLD(f) abuf->fields.sfmt_addi.f
 248   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 249   int UNUSED written = 0;
 250   IADDR UNUSED pc = abuf->addr;
 251   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 252
 253   {
 254     SI opval = ADDSI (GET_H_GR (FLD (f_rs)), EXTHISI (TRUNCSIHI (FLD (f_imm))));
 255     SET_H_GR (FLD (f_rt), opval);
 256     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 257   }
 258
 259   return vpc;
 260 #undef FLD
 261 }
 262
 263 /* addu: addu $rd,$rs,$rt */
 264
 265 static SEM_PC
 266 SEM_FN_NAME (iq2000bf,addu) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 267 {
 268 #define FLD(f) abuf->fields.sfmt_mrgb.f
 269   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 270   int UNUSED written = 0;
 271   IADDR UNUSED pc = abuf->addr;
 272   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 273
 274   {
 275     SI opval = ADDSI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)));
 276     SET_H_GR (FLD (f_rd), opval);
 277     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 278   }
 279
 280   return vpc;
 281 #undef FLD
 282 }
 283
 284 /* ado16: ado16 $rd,$rs,$rt */
 285
 286 static SEM_PC
 287 SEM_FN_NAME (iq2000bf,ado16) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 288 {
 289 #define FLD(f) abuf->fields.sfmt_mrgb.f
 290   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 291   int UNUSED written = 0;
 292   IADDR UNUSED pc = abuf->addr;
 293   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 294
 295 {
 296   HI tmp_high;
 297   HI tmp_low;
 298   tmp_low = ADDHI (ANDHI (GET_H_GR (FLD (f_rs)), 65535), ANDHI (GET_H_GR (FLD (f_rt)), 65535));
 299   tmp_high = ADDHI (SRLSI (GET_H_GR (FLD (f_rs)), 16), SRLSI (GET_H_GR (FLD (f_rt)), 16));
 300   {
 301     SI opval = ORSI (SLLSI (tmp_high, 16), tmp_low);
 302     SET_H_GR (FLD (f_rd), opval);
 303     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 304   }
 305 }
 306
 307   return vpc;
 308 #undef FLD
 309 }
 310
 311 /* and: and $rd,$rs,$rt */
 312
 313 static SEM_PC
 314 SEM_FN_NAME (iq2000bf,and) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 315 {
 316 #define FLD(f) abuf->fields.sfmt_mrgb.f
 317   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 318   int UNUSED written = 0;
 319   IADDR UNUSED pc = abuf->addr;
 320   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 321
 322   {
 323     SI opval = ANDSI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)));
 324     SET_H_GR (FLD (f_rd), opval);
 325     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 326   }
 327
 328   return vpc;
 329 #undef FLD
 330 }
 331
 332 /* andi: andi $rt,$rs,$lo16 */
 333
 334 static SEM_PC
 335 SEM_FN_NAME (iq2000bf,andi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 336 {
 337 #define FLD(f) abuf->fields.sfmt_addi.f
 338   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 339   int UNUSED written = 0;
 340   IADDR UNUSED pc = abuf->addr;
 341   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 342
 343   {
 344     SI opval = ANDSI (GET_H_GR (FLD (f_rs)), ZEXTSISI (FLD (f_imm)));
 345     SET_H_GR (FLD (f_rt), opval);
 346     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 347   }
 348
 349   return vpc;
 350 #undef FLD
 351 }
 352
 353 /* andoi: andoi $rt,$rs,$lo16 */
 354
 355 static SEM_PC
 356 SEM_FN_NAME (iq2000bf,andoi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 357 {
 358 #define FLD(f) abuf->fields.sfmt_addi.f
 359   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 360   int UNUSED written = 0;
 361   IADDR UNUSED pc = abuf->addr;
 362   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 363
 364   {
 365     SI opval = ANDSI (GET_H_GR (FLD (f_rs)), ORSI (0xffff0000, EXTHISI (TRUNCSIHI (FLD (f_imm)))));
 366     SET_H_GR (FLD (f_rt), opval);
 367     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 368   }
 369
 370   return vpc;
 371 #undef FLD
 372 }
 373
 374 /* nor: nor $rd,$rs,$rt */
 375
 376 static SEM_PC
 377 SEM_FN_NAME (iq2000bf,nor) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 378 {
 379 #define FLD(f) abuf->fields.sfmt_mrgb.f
 380   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 381   int UNUSED written = 0;
 382   IADDR UNUSED pc = abuf->addr;
 383   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 384
 385   {
 386     SI opval = INVSI (ORSI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt))));
 387     SET_H_GR (FLD (f_rd), opval);
 388     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 389   }
 390
 391   return vpc;
 392 #undef FLD
 393 }
 394
 395 /* or: or $rd,$rs,$rt */
 396
 397 static SEM_PC
 398 SEM_FN_NAME (iq2000bf,or) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 399 {
 400 #define FLD(f) abuf->fields.sfmt_mrgb.f
 401   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 402   int UNUSED written = 0;
 403   IADDR UNUSED pc = abuf->addr;
 404   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 405
 406   {
 407     SI opval = ORSI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)));
 408     SET_H_GR (FLD (f_rd), opval);
 409     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 410   }
 411
 412   return vpc;
 413 #undef FLD
 414 }
 415
 416 /* ori: ori $rt,$rs,$lo16 */
 417
 418 static SEM_PC
 419 SEM_FN_NAME (iq2000bf,ori) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 420 {
 421 #define FLD(f) abuf->fields.sfmt_addi.f
 422   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 423   int UNUSED written = 0;
 424   IADDR UNUSED pc = abuf->addr;
 425   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 426
 427   {
 428     SI opval = ORSI (GET_H_GR (FLD (f_rs)), ZEXTSISI (FLD (f_imm)));
 429     SET_H_GR (FLD (f_rt), opval);
 430     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 431   }
 432
 433   return vpc;
 434 #undef FLD
 435 }
 436
 437 /* ram: ram $rd,$rt,$shamt,$maskl,$maskr */
 438
 439 static SEM_PC
 440 SEM_FN_NAME (iq2000bf,ram) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 441 {
 442 #define FLD(f) abuf->fields.sfmt_ram.f
 443   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 444   int UNUSED written = 0;
 445   IADDR UNUSED pc = abuf->addr;
 446   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 447
 448 {
 449   {
 450     SI opval = RORSI (GET_H_GR (FLD (f_rt)), FLD (f_shamt));
 451     SET_H_GR (FLD (f_rd), opval);
 452     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 453   }
 454   {
 455     SI opval = ANDSI (GET_H_GR (FLD (f_rd)), SRLSI (0xffffffff, FLD (f_maskl)));
 456     SET_H_GR (FLD (f_rd), opval);
 457     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 458   }
 459   {
 460     SI opval = ANDSI (GET_H_GR (FLD (f_rd)), SLLSI (0xffffffff, FLD (f_rs)));
 461     SET_H_GR (FLD (f_rd), opval);
 462     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 463   }
 464 }
 465
 466   return vpc;
 467 #undef FLD
 468 }
 469
 470 /* sll: sll $rd,$rt,$shamt */
 471
 472 static SEM_PC
 473 SEM_FN_NAME (iq2000bf,sll) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 474 {
 475 #define FLD(f) abuf->fields.sfmt_ram.f
 476   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 477   int UNUSED written = 0;
 478   IADDR UNUSED pc = abuf->addr;
 479   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 480
 481   {
 482     SI opval = SLLSI (GET_H_GR (FLD (f_rt)), FLD (f_shamt));
 483     SET_H_GR (FLD (f_rd), opval);
 484     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 485   }
 486
 487   return vpc;
 488 #undef FLD
 489 }
 490
 491 /* sllv: sllv $rd,$rt,$rs */
 492
 493 static SEM_PC
 494 SEM_FN_NAME (iq2000bf,sllv) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 495 {
 496 #define FLD(f) abuf->fields.sfmt_mrgb.f
 497   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 498   int UNUSED written = 0;
 499   IADDR UNUSED pc = abuf->addr;
 500   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 501
 502   {
 503     SI opval = SLLSI (GET_H_GR (FLD (f_rt)), ANDSI (GET_H_GR (FLD (f_rs)), 31));
 504     SET_H_GR (FLD (f_rd), opval);
 505     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 506   }
 507
 508   return vpc;
 509 #undef FLD
 510 }
 511
 512 /* slmv: slmv $rd,$rt,$rs,$shamt */
 513
 514 static SEM_PC
 515 SEM_FN_NAME (iq2000bf,slmv) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 516 {
 517 #define FLD(f) abuf->fields.sfmt_ram.f
 518   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 519   int UNUSED written = 0;
 520   IADDR UNUSED pc = abuf->addr;
 521   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 522
 523   {
 524     SI opval = ANDSI (SLLSI (GET_H_GR (FLD (f_rt)), FLD (f_shamt)), SRLSI (0xffffffff, GET_H_GR (FLD (f_rs))));
 525     SET_H_GR (FLD (f_rd), opval);
 526     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 527   }
 528
 529   return vpc;
 530 #undef FLD
 531 }
 532
 533 /* slt: slt $rd,$rs,$rt */
 534
 535 static SEM_PC
 536 SEM_FN_NAME (iq2000bf,slt) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 537 {
 538 #define FLD(f) abuf->fields.sfmt_mrgb.f
 539   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 540   int UNUSED written = 0;
 541   IADDR UNUSED pc = abuf->addr;
 542   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 543
 544 if (LTSI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)))) {
 545   {
 546     SI opval = 1;
 547     SET_H_GR (FLD (f_rd), opval);
 548     written |= (1 << 2);
 549     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 550   }
 551 } else {
 552   {
 553     SI opval = 0;
 554     SET_H_GR (FLD (f_rd), opval);
 555     written |= (1 << 2);
 556     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 557   }
 558 }
 559
 560   abuf->written = written;
 561   return vpc;
 562 #undef FLD
 563 }
 564
 565 /* slti: slti $rt,$rs,$imm */
 566
 567 static SEM_PC
 568 SEM_FN_NAME (iq2000bf,slti) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 569 {
 570 #define FLD(f) abuf->fields.sfmt_addi.f
 571   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 572   int UNUSED written = 0;
 573   IADDR UNUSED pc = abuf->addr;
 574   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 575
 576 if (LTSI (GET_H_GR (FLD (f_rs)), EXTHISI (TRUNCSIHI (FLD (f_imm))))) {
 577   {
 578     SI opval = 1;
 579     SET_H_GR (FLD (f_rt), opval);
 580     written |= (1 << 2);
 581     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 582   }
 583 } else {
 584   {
 585     SI opval = 0;
 586     SET_H_GR (FLD (f_rt), opval);
 587     written |= (1 << 2);
 588     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 589   }
 590 }
 591
 592   abuf->written = written;
 593   return vpc;
 594 #undef FLD
 595 }
 596
 597 /* sltiu: sltiu $rt,$rs,$imm */
 598
 599 static SEM_PC
 600 SEM_FN_NAME (iq2000bf,sltiu) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 601 {
 602 #define FLD(f) abuf->fields.sfmt_addi.f
 603   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 604   int UNUSED written = 0;
 605   IADDR UNUSED pc = abuf->addr;
 606   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 607
 608 if (LTUSI (GET_H_GR (FLD (f_rs)), EXTHISI (TRUNCSIHI (FLD (f_imm))))) {
 609   {
 610     SI opval = 1;
 611     SET_H_GR (FLD (f_rt), opval);
 612     written |= (1 << 2);
 613     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 614   }
 615 } else {
 616   {
 617     SI opval = 0;
 618     SET_H_GR (FLD (f_rt), opval);
 619     written |= (1 << 2);
 620     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 621   }
 622 }
 623
 624   abuf->written = written;
 625   return vpc;
 626 #undef FLD
 627 }
 628
 629 /* sltu: sltu $rd,$rs,$rt */
 630
 631 static SEM_PC
 632 SEM_FN_NAME (iq2000bf,sltu) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 633 {
 634 #define FLD(f) abuf->fields.sfmt_mrgb.f
 635   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 636   int UNUSED written = 0;
 637   IADDR UNUSED pc = abuf->addr;
 638   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 639
 640 if (LTUSI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)))) {
 641   {
 642     SI opval = 1;
 643     SET_H_GR (FLD (f_rd), opval);
 644     written |= (1 << 2);
 645     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 646   }
 647 } else {
 648   {
 649     SI opval = 0;
 650     SET_H_GR (FLD (f_rd), opval);
 651     written |= (1 << 2);
 652     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 653   }
 654 }
 655
 656   abuf->written = written;
 657   return vpc;
 658 #undef FLD
 659 }
 660
 661 /* sra: sra $rd,$rt,$shamt */
 662
 663 static SEM_PC
 664 SEM_FN_NAME (iq2000bf,sra) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 665 {
 666 #define FLD(f) abuf->fields.sfmt_ram.f
 667   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 668   int UNUSED written = 0;
 669   IADDR UNUSED pc = abuf->addr;
 670   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 671
 672   {
 673     SI opval = SRASI (GET_H_GR (FLD (f_rt)), FLD (f_shamt));
 674     SET_H_GR (FLD (f_rd), opval);
 675     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 676   }
 677
 678   return vpc;
 679 #undef FLD
 680 }
 681
 682 /* srav: srav $rd,$rt,$rs */
 683
 684 static SEM_PC
 685 SEM_FN_NAME (iq2000bf,srav) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 686 {
 687 #define FLD(f) abuf->fields.sfmt_mrgb.f
 688   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 689   int UNUSED written = 0;
 690   IADDR UNUSED pc = abuf->addr;
 691   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 692
 693   {
 694     SI opval = SRASI (GET_H_GR (FLD (f_rt)), ANDSI (GET_H_GR (FLD (f_rs)), 31));
 695     SET_H_GR (FLD (f_rd), opval);
 696     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 697   }
 698
 699   return vpc;
 700 #undef FLD
 701 }
 702
 703 /* srl: srl $rd,$rt,$shamt */
 704
 705 static SEM_PC
 706 SEM_FN_NAME (iq2000bf,srl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 707 {
 708 #define FLD(f) abuf->fields.sfmt_ram.f
 709   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 710   int UNUSED written = 0;
 711   IADDR UNUSED pc = abuf->addr;
 712   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 713
 714   {
 715     SI opval = SRLSI (GET_H_GR (FLD (f_rt)), FLD (f_shamt));
 716     SET_H_GR (FLD (f_rd), opval);
 717     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 718   }
 719
 720   return vpc;
 721 #undef FLD
 722 }
 723
 724 /* srlv: srlv $rd,$rt,$rs */
 725
 726 static SEM_PC
 727 SEM_FN_NAME (iq2000bf,srlv) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 728 {
 729 #define FLD(f) abuf->fields.sfmt_mrgb.f
 730   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 731   int UNUSED written = 0;
 732   IADDR UNUSED pc = abuf->addr;
 733   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 734
 735   {
 736     SI opval = SRLSI (GET_H_GR (FLD (f_rt)), ANDSI (GET_H_GR (FLD (f_rs)), 31));
 737     SET_H_GR (FLD (f_rd), opval);
 738     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 739   }
 740
 741   return vpc;
 742 #undef FLD
 743 }
 744
 745 /* srmv: srmv $rd,$rt,$rs,$shamt */
 746
 747 static SEM_PC
 748 SEM_FN_NAME (iq2000bf,srmv) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 749 {
 750 #define FLD(f) abuf->fields.sfmt_ram.f
 751   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 752   int UNUSED written = 0;
 753   IADDR UNUSED pc = abuf->addr;
 754   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 755
 756   {
 757     SI opval = ANDSI (SRLSI (GET_H_GR (FLD (f_rt)), FLD (f_shamt)), SLLSI (0xffffffff, GET_H_GR (FLD (f_rs))));
 758     SET_H_GR (FLD (f_rd), opval);
 759     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 760   }
 761
 762   return vpc;
 763 #undef FLD
 764 }
 765
 766 /* sub: sub $rd,$rs,$rt */
 767
 768 static SEM_PC
 769 SEM_FN_NAME (iq2000bf,sub) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 770 {
 771 #define FLD(f) abuf->fields.sfmt_mrgb.f
 772   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 773   int UNUSED written = 0;
 774   IADDR UNUSED pc = abuf->addr;
 775   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 776
 777   {
 778     SI opval = SUBSI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)));
 779     SET_H_GR (FLD (f_rd), opval);
 780     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 781   }
 782
 783   return vpc;
 784 #undef FLD
 785 }
 786
 787 /* subu: subu $rd,$rs,$rt */
 788
 789 static SEM_PC
 790 SEM_FN_NAME (iq2000bf,subu) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 791 {
 792 #define FLD(f) abuf->fields.sfmt_mrgb.f
 793   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 794   int UNUSED written = 0;
 795   IADDR UNUSED pc = abuf->addr;
 796   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 797
 798   {
 799     SI opval = SUBSI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)));
 800     SET_H_GR (FLD (f_rd), opval);
 801     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 802   }
 803
 804   return vpc;
 805 #undef FLD
 806 }
 807
 808 /* xor: xor $rd,$rs,$rt */
 809
 810 static SEM_PC
 811 SEM_FN_NAME (iq2000bf,xor) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 812 {
 813 #define FLD(f) abuf->fields.sfmt_mrgb.f
 814   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 815   int UNUSED written = 0;
 816   IADDR UNUSED pc = abuf->addr;
 817   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 818
 819   {
 820     SI opval = XORSI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)));
 821     SET_H_GR (FLD (f_rd), opval);
 822     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 823   }
 824
 825   return vpc;
 826 #undef FLD
 827 }
 828
 829 /* xori: xori $rt,$rs,$lo16 */
 830
 831 static SEM_PC
 832 SEM_FN_NAME (iq2000bf,xori) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 833 {
 834 #define FLD(f) abuf->fields.sfmt_addi.f
 835   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 836   int UNUSED written = 0;
 837   IADDR UNUSED pc = abuf->addr;
 838   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 839
 840   {
 841     SI opval = XORSI (GET_H_GR (FLD (f_rs)), ZEXTSISI (FLD (f_imm)));
 842     SET_H_GR (FLD (f_rt), opval);
 843     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 844   }
 845
 846   return vpc;
 847 #undef FLD
 848 }
 849
 850 /* bbi: bbi $rs($bitnum),$offset */
 851
 852 static SEM_PC
 853 SEM_FN_NAME (iq2000bf,bbi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 854 {
 855 #define FLD(f) abuf->fields.sfmt_bbi.f
 856   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 857   int UNUSED written = 0;
 858   IADDR UNUSED pc = abuf->addr;
 859   SEM_BRANCH_INIT
 860   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 861
 862 if (ANDSI (GET_H_GR (FLD (f_rs)), SLLSI (1, FLD (f_rt)))) {
 863 {
 864   {
 865     USI opval = FLD (i_offset);
 866     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 867     written |= (1 << 3);
 868     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 869   }
 870 }
 871 }
 872
 873   abuf->written = written;
 874   SEM_BRANCH_FINI (vpc);
 875   return vpc;
 876 #undef FLD
 877 }
 878
 879 /* bbin: bbin $rs($bitnum),$offset */
 880
 881 static SEM_PC
 882 SEM_FN_NAME (iq2000bf,bbin) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 883 {
 884 #define FLD(f) abuf->fields.sfmt_bbi.f
 885   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 886   int UNUSED written = 0;
 887   IADDR UNUSED pc = abuf->addr;
 888   SEM_BRANCH_INIT
 889   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 890
 891 if (NOTSI (ANDSI (GET_H_GR (FLD (f_rs)), SLLSI (1, FLD (f_rt))))) {
 892 {
 893   {
 894     USI opval = FLD (i_offset);
 895     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 896     written |= (1 << 3);
 897     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 898   }
 899 }
 900 }
 901
 902   abuf->written = written;
 903   SEM_BRANCH_FINI (vpc);
 904   return vpc;
 905 #undef FLD
 906 }
 907
 908 /* bbv: bbv $rs,$rt,$offset */
 909
 910 static SEM_PC
 911 SEM_FN_NAME (iq2000bf,bbv) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 912 {
 913 #define FLD(f) abuf->fields.sfmt_bbi.f
 914   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 915   int UNUSED written = 0;
 916   IADDR UNUSED pc = abuf->addr;
 917   SEM_BRANCH_INIT
 918   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 919
 920 if (ANDSI (GET_H_GR (FLD (f_rs)), SLLSI (1, ANDSI (GET_H_GR (FLD (f_rt)), 31)))) {
 921 {
 922   {
 923     USI opval = FLD (i_offset);
 924     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 925     written |= (1 << 3);
 926     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 927   }
 928 }
 929 }
 930
 931   abuf->written = written;
 932   SEM_BRANCH_FINI (vpc);
 933   return vpc;
 934 #undef FLD
 935 }
 936
 937 /* bbvn: bbvn $rs,$rt,$offset */
 938
 939 static SEM_PC
 940 SEM_FN_NAME (iq2000bf,bbvn) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 941 {
 942 #define FLD(f) abuf->fields.sfmt_bbi.f
 943   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 944   int UNUSED written = 0;
 945   IADDR UNUSED pc = abuf->addr;
 946   SEM_BRANCH_INIT
 947   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 948
 949 if (NOTSI (ANDSI (GET_H_GR (FLD (f_rs)), SLLSI (1, ANDSI (GET_H_GR (FLD (f_rt)), 31))))) {
 950 {
 951   {
 952     USI opval = FLD (i_offset);
 953     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 954     written |= (1 << 3);
 955     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 956   }
 957 }
 958 }
 959
 960   abuf->written = written;
 961   SEM_BRANCH_FINI (vpc);
 962   return vpc;
 963 #undef FLD
 964 }
 965
 966 /* beq: beq $rs,$rt,$offset */
 967
 968 static SEM_PC
 969 SEM_FN_NAME (iq2000bf,beq) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 970 {
 971 #define FLD(f) abuf->fields.sfmt_bbi.f
 972   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 973   int UNUSED written = 0;
 974   IADDR UNUSED pc = abuf->addr;
 975   SEM_BRANCH_INIT
 976   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 977
 978 if (EQSI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)))) {
 979 {
 980   {
 981     USI opval = FLD (i_offset);
 982     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 983     written |= (1 << 3);
 984     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 985   }
 986 }
 987 }
 988
 989   abuf->written = written;
 990   SEM_BRANCH_FINI (vpc);
 991   return vpc;
 992 #undef FLD
 993 }
 994
 995 /* beql: beql $rs,$rt,$offset */
 996
 997 static SEM_PC
 998 SEM_FN_NAME (iq2000bf,beql) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 999 {
1000 #define FLD(f) abuf->fields.sfmt_bbi.f
1001   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1002   int UNUSED written = 0;
1003   IADDR UNUSED pc = abuf->addr;
1004   SEM_BRANCH_INIT
1005   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1006
1007 if (EQSI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)))) {
1008 {
1009   {
1010     USI opval = FLD (i_offset);
1011     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1012     written |= (1 << 3);
1013     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1014   }
1015 }
1016 } else {
1017 if (1)
1018   SEM_SKIP_INSN (current_cpu, sem_arg, vpc);
1019 }
1020
1021   abuf->written = written;
1022   SEM_BRANCH_FINI (vpc);
1023   return vpc;
1024 #undef FLD
1025 }
1026
1027 /* bgez: bgez $rs,$offset */
1028
1029 static SEM_PC
1030 SEM_FN_NAME (iq2000bf,bgez) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1031 {
1032 #define FLD(f) abuf->fields.sfmt_bbi.f
1033   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1034   int UNUSED written = 0;
1035   IADDR UNUSED pc = abuf->addr;
1036   SEM_BRANCH_INIT
1037   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1038
1039 if (GESI (GET_H_GR (FLD (f_rs)), 0)) {
1040 {
1041   {
1042     USI opval = FLD (i_offset);
1043     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1044     written |= (1 << 2);
1045     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1046   }
1047 }
1048 }
1049
1050   abuf->written = written;
1051   SEM_BRANCH_FINI (vpc);
1052   return vpc;
1053 #undef FLD
1054 }
1055
1056 /* bgezal: bgezal $rs,$offset */
1057
1058 static SEM_PC
1059 SEM_FN_NAME (iq2000bf,bgezal) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1060 {
1061 #define FLD(f) abuf->fields.sfmt_bbi.f
1062   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1063   int UNUSED written = 0;
1064   IADDR UNUSED pc = abuf->addr;
1065   SEM_BRANCH_INIT
1066   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1067
1068 if (GESI (GET_H_GR (FLD (f_rs)), 0)) {
1069 {
1070   {
1071     SI opval = ADDSI (pc, 8);
1072     SET_H_GR (((UINT) 31), opval);
1073     written |= (1 << 3);
1074     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1075   }
1076 {
1077   {
1078     USI opval = FLD (i_offset);
1079     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1080     written |= (1 << 4);
1081     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1082   }
1083 }
1084 }
1085 }
1086
1087   abuf->written = written;
1088   SEM_BRANCH_FINI (vpc);
1089   return vpc;
1090 #undef FLD
1091 }
1092
1093 /* bgezall: bgezall $rs,$offset */
1094
1095 static SEM_PC
1096 SEM_FN_NAME (iq2000bf,bgezall) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1097 {
1098 #define FLD(f) abuf->fields.sfmt_bbi.f
1099   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1100   int UNUSED written = 0;
1101   IADDR UNUSED pc = abuf->addr;
1102   SEM_BRANCH_INIT
1103   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1104
1105 if (GESI (GET_H_GR (FLD (f_rs)), 0)) {
1106 {
1107   {
1108     SI opval = ADDSI (pc, 8);
1109     SET_H_GR (((UINT) 31), opval);
1110     written |= (1 << 3);
1111     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1112   }
1113 {
1114   {
1115     USI opval = FLD (i_offset);
1116     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1117     written |= (1 << 4);
1118     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1119   }
1120 }
1121 }
1122 } else {
1123 if (1)
1124   SEM_SKIP_INSN (current_cpu, sem_arg, vpc);
1125 }
1126
1127   abuf->written = written;
1128   SEM_BRANCH_FINI (vpc);
1129   return vpc;
1130 #undef FLD
1131 }
1132
1133 /* bgezl: bgezl $rs,$offset */
1134
1135 static SEM_PC
1136 SEM_FN_NAME (iq2000bf,bgezl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1137 {
1138 #define FLD(f) abuf->fields.sfmt_bbi.f
1139   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1140   int UNUSED written = 0;
1141   IADDR UNUSED pc = abuf->addr;
1142   SEM_BRANCH_INIT
1143   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1144
1145 if (GESI (GET_H_GR (FLD (f_rs)), 0)) {
1146 {
1147   {
1148     USI opval = FLD (i_offset);
1149     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1150     written |= (1 << 2);
1151     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1152   }
1153 }
1154 } else {
1155 if (1)
1156   SEM_SKIP_INSN (current_cpu, sem_arg, vpc);
1157 }
1158
1159   abuf->written = written;
1160   SEM_BRANCH_FINI (vpc);
1161   return vpc;
1162 #undef FLD
1163 }
1164
1165 /* bltz: bltz $rs,$offset */
1166
1167 static SEM_PC
1168 SEM_FN_NAME (iq2000bf,bltz) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1169 {
1170 #define FLD(f) abuf->fields.sfmt_bbi.f
1171   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1172   int UNUSED written = 0;
1173   IADDR UNUSED pc = abuf->addr;
1174   SEM_BRANCH_INIT
1175   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1176
1177 if (LTSI (GET_H_GR (FLD (f_rs)), 0)) {
1178 {
1179   {
1180     USI opval = FLD (i_offset);
1181     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1182     written |= (1 << 2);
1183     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1184   }
1185 }
1186 }
1187
1188   abuf->written = written;
1189   SEM_BRANCH_FINI (vpc);
1190   return vpc;
1191 #undef FLD
1192 }
1193
1194 /* bltzl: bltzl $rs,$offset */
1195
1196 static SEM_PC
1197 SEM_FN_NAME (iq2000bf,bltzl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1198 {
1199 #define FLD(f) abuf->fields.sfmt_bbi.f
1200   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1201   int UNUSED written = 0;
1202   IADDR UNUSED pc = abuf->addr;
1203   SEM_BRANCH_INIT
1204   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1205
1206 if (LTSI (GET_H_GR (FLD (f_rs)), 0)) {
1207 {
1208   {
1209     USI opval = FLD (i_offset);
1210     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1211     written |= (1 << 2);
1212     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1213   }
1214 }
1215 } else {
1216 if (1)
1217   SEM_SKIP_INSN (current_cpu, sem_arg, vpc);
1218 }
1219
1220   abuf->written = written;
1221   SEM_BRANCH_FINI (vpc);
1222   return vpc;
1223 #undef FLD
1224 }
1225
1226 /* bltzal: bltzal $rs,$offset */
1227
1228 static SEM_PC
1229 SEM_FN_NAME (iq2000bf,bltzal) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1230 {
1231 #define FLD(f) abuf->fields.sfmt_bbi.f
1232   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1233   int UNUSED written = 0;
1234   IADDR UNUSED pc = abuf->addr;
1235   SEM_BRANCH_INIT
1236   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1237
1238 if (LTSI (GET_H_GR (FLD (f_rs)), 0)) {
1239 {
1240   {
1241     SI opval = ADDSI (pc, 8);
1242     SET_H_GR (((UINT) 31), opval);
1243     written |= (1 << 3);
1244     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1245   }
1246 {
1247   {
1248     USI opval = FLD (i_offset);
1249     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1250     written |= (1 << 4);
1251     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1252   }
1253 }
1254 }
1255 }
1256
1257   abuf->written = written;
1258   SEM_BRANCH_FINI (vpc);
1259   return vpc;
1260 #undef FLD
1261 }
1262
1263 /* bltzall: bltzall $rs,$offset */
1264
1265 static SEM_PC
1266 SEM_FN_NAME (iq2000bf,bltzall) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1267 {
1268 #define FLD(f) abuf->fields.sfmt_bbi.f
1269   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1270   int UNUSED written = 0;
1271   IADDR UNUSED pc = abuf->addr;
1272   SEM_BRANCH_INIT
1273   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1274
1275 if (LTSI (GET_H_GR (FLD (f_rs)), 0)) {
1276 {
1277   {
1278     SI opval = ADDSI (pc, 8);
1279     SET_H_GR (((UINT) 31), opval);
1280     written |= (1 << 3);
1281     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1282   }
1283 {
1284   {
1285     USI opval = FLD (i_offset);
1286     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1287     written |= (1 << 4);
1288     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1289   }
1290 }
1291 }
1292 } else {
1293 if (1)
1294   SEM_SKIP_INSN (current_cpu, sem_arg, vpc);
1295 }
1296
1297   abuf->written = written;
1298   SEM_BRANCH_FINI (vpc);
1299   return vpc;
1300 #undef FLD
1301 }
1302
1303 /* bmb0: bmb0 $rs,$rt,$offset */
1304
1305 static SEM_PC
1306 SEM_FN_NAME (iq2000bf,bmb0) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1307 {
1308 #define FLD(f) abuf->fields.sfmt_bbi.f
1309   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1310   int UNUSED written = 0;
1311   IADDR UNUSED pc = abuf->addr;
1312   SEM_BRANCH_INIT
1313   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1314
1315 if (EQSI (ANDSI (GET_H_GR (FLD (f_rs)), 255), ANDSI (GET_H_GR (FLD (f_rt)), 255))) {
1316 {
1317   {
1318     USI opval = FLD (i_offset);
1319     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1320     written |= (1 << 3);
1321     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1322   }
1323 }
1324 }
1325
1326   abuf->written = written;
1327   SEM_BRANCH_FINI (vpc);
1328   return vpc;
1329 #undef FLD
1330 }
1331
1332 /* bmb1: bmb1 $rs,$rt,$offset */
1333
1334 static SEM_PC
1335 SEM_FN_NAME (iq2000bf,bmb1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1336 {
1337 #define FLD(f) abuf->fields.sfmt_bbi.f
1338   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1339   int UNUSED written = 0;
1340   IADDR UNUSED pc = abuf->addr;
1341   SEM_BRANCH_INIT
1342   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1343
1344 if (EQSI (ANDSI (GET_H_GR (FLD (f_rs)), 65280), ANDSI (GET_H_GR (FLD (f_rt)), 65280))) {
1345 {
1346   {
1347     USI opval = FLD (i_offset);
1348     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1349     written |= (1 << 3);
1350     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1351   }
1352 }
1353 }
1354
1355   abuf->written = written;
1356   SEM_BRANCH_FINI (vpc);
1357   return vpc;
1358 #undef FLD
1359 }
1360
1361 /* bmb2: bmb2 $rs,$rt,$offset */
1362
1363 static SEM_PC
1364 SEM_FN_NAME (iq2000bf,bmb2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1365 {
1366 #define FLD(f) abuf->fields.sfmt_bbi.f
1367   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1368   int UNUSED written = 0;
1369   IADDR UNUSED pc = abuf->addr;
1370   SEM_BRANCH_INIT
1371   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1372
1373 if (EQSI (ANDSI (GET_H_GR (FLD (f_rs)), 16711680), ANDSI (GET_H_GR (FLD (f_rt)), 16711680))) {
1374 {
1375   {
1376     USI opval = FLD (i_offset);
1377     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1378     written |= (1 << 3);
1379     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1380   }
1381 }
1382 }
1383
1384   abuf->written = written;
1385   SEM_BRANCH_FINI (vpc);
1386   return vpc;
1387 #undef FLD
1388 }
1389
1390 /* bmb3: bmb3 $rs,$rt,$offset */
1391
1392 static SEM_PC
1393 SEM_FN_NAME (iq2000bf,bmb3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1394 {
1395 #define FLD(f) abuf->fields.sfmt_bbi.f
1396   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1397   int UNUSED written = 0;
1398   IADDR UNUSED pc = abuf->addr;
1399   SEM_BRANCH_INIT
1400   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1401
1402 if (EQSI (ANDSI (GET_H_GR (FLD (f_rs)), 0xff000000), ANDSI (GET_H_GR (FLD (f_rt)), 0xff000000))) {
1403 {
1404   {
1405     USI opval = FLD (i_offset);
1406     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1407     written |= (1 << 3);
1408     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1409   }
1410 }
1411 }
1412
1413   abuf->written = written;
1414   SEM_BRANCH_FINI (vpc);
1415   return vpc;
1416 #undef FLD
1417 }
1418
1419 /* bne: bne $rs,$rt,$offset */
1420
1421 static SEM_PC
1422 SEM_FN_NAME (iq2000bf,bne) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1423 {
1424 #define FLD(f) abuf->fields.sfmt_bbi.f
1425   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1426   int UNUSED written = 0;
1427   IADDR UNUSED pc = abuf->addr;
1428   SEM_BRANCH_INIT
1429   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1430
1431 if (NESI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)))) {
1432 {
1433   {
1434     USI opval = FLD (i_offset);
1435     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1436     written |= (1 << 3);
1437     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1438   }
1439 }
1440 }
1441
1442   abuf->written = written;
1443   SEM_BRANCH_FINI (vpc);
1444   return vpc;
1445 #undef FLD
1446 }
1447
1448 /* bnel: bnel $rs,$rt,$offset */
1449
1450 static SEM_PC
1451 SEM_FN_NAME (iq2000bf,bnel) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1452 {
1453 #define FLD(f) abuf->fields.sfmt_bbi.f
1454   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1455   int UNUSED written = 0;
1456   IADDR UNUSED pc = abuf->addr;
1457   SEM_BRANCH_INIT
1458   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1459
1460 if (NESI (GET_H_GR (FLD (f_rs)), GET_H_GR (FLD (f_rt)))) {
1461 {
1462   {
1463     USI opval = FLD (i_offset);
1464     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1465     written |= (1 << 3);
1466     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1467   }
1468 }
1469 } else {
1470 if (1)
1471   SEM_SKIP_INSN (current_cpu, sem_arg, vpc);
1472 }
1473
1474   abuf->written = written;
1475   SEM_BRANCH_FINI (vpc);
1476   return vpc;
1477 #undef FLD
1478 }
1479
1480 /* jalr: jalr $rd,$rs */
1481
1482 static SEM_PC
1483 SEM_FN_NAME (iq2000bf,jalr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1484 {
1485 #define FLD(f) abuf->fields.sfmt_mrgb.f
1486   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1487   int UNUSED written = 0;
1488   IADDR UNUSED pc = abuf->addr;
1489   SEM_BRANCH_INIT
1490   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1491
1492 {
1493 {
1494   {
1495     SI opval = ADDSI (pc, 8);
1496     SET_H_GR (FLD (f_rd), opval);
1497     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1498   }
1499   {
1500     USI opval = GET_H_GR (FLD (f_rs));
1501     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
1502     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1503   }
1504 }
1505 }
1506
1507   SEM_BRANCH_FINI (vpc);
1508   return vpc;
1509 #undef FLD
1510 }
1511
1512 /* jr: jr $rs */
1513
1514 static SEM_PC
1515 SEM_FN_NAME (iq2000bf,jr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1516 {
1517 #define FLD(f) abuf->fields.sfmt_bbi.f
1518   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1519   int UNUSED written = 0;
1520   IADDR UNUSED pc = abuf->addr;
1521   SEM_BRANCH_INIT
1522   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1523
1524 {
1525   {
1526     USI opval = GET_H_GR (FLD (f_rs));
1527     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
1528     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1529   }
1530 }
1531
1532   SEM_BRANCH_FINI (vpc);
1533   return vpc;
1534 #undef FLD
1535 }
1536
1537 /* lb: lb $rt,$lo16($base) */
1538
1539 static SEM_PC
1540 SEM_FN_NAME (iq2000bf,lb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1541 {
1542 #define FLD(f) abuf->fields.sfmt_addi.f
1543   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1544   int UNUSED written = 0;
1545   IADDR UNUSED pc = abuf->addr;
1546   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1547
1548   {
1549     SI opval = EXTQISI (GETMEMQI (current_cpu, pc, ADDSI (GET_H_GR (FLD (f_rs)), EXTHISI (TRUNCSIHI (FLD (f_imm))))));
1550     SET_H_GR (FLD (f_rt), opval);
1551     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1552   }
1553
1554   return vpc;
1555 #undef FLD
1556 }
1557
1558 /* lbu: lbu $rt,$lo16($base) */
1559
1560 static SEM_PC
1561 SEM_FN_NAME (iq2000bf,lbu) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1562 {
1563 #define FLD(f) abuf->fields.sfmt_addi.f
1564   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1565   int UNUSED written = 0;
1566   IADDR UNUSED pc = abuf->addr;
1567   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1568
1569   {
1570     SI opval = ZEXTQISI (GETMEMQI (current_cpu, pc, ADDSI (GET_H_GR (FLD (f_rs)), EXTHISI (TRUNCSIHI (FLD (f_imm))))));
1571     SET_H_GR (FLD (f_rt), opval);
1572     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1573   }
1574
1575   return vpc;
1576 #undef FLD
1577 }
1578
1579 /* lh: lh $rt,$lo16($base) */
1580
1581 static SEM_PC
1582 SEM_FN_NAME (iq2000bf,lh) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1583 {
1584 #define FLD(f) abuf->fields.sfmt_addi.f
1585   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1586   int UNUSED written = 0;
1587   IADDR UNUSED pc = abuf->addr;
1588   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1589
1590   {
1591     SI opval = EXTHISI (GETMEMHI (current_cpu, pc, ADDSI (GET_H_GR (FLD (f_rs)), EXTHISI (TRUNCSIHI (FLD (f_imm))))));
1592     SET_H_GR (FLD (f_rt), opval);
1593     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1594   }
1595
1596   return vpc;
1597 #undef FLD
1598 }
1599
1600 /* lhu: lhu $rt,$lo16($base) */
1601
1602 static SEM_PC
1603 SEM_FN_NAME (iq2000bf,lhu) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1604 {
1605 #define FLD(f) abuf->fields.sfmt_addi.f
1606   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1607   int UNUSED written = 0;
1608   IADDR UNUSED pc = abuf->addr;
1609   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1610
1611   {
1612     SI opval = ZEXTHISI (GETMEMHI (current_cpu, pc, ADDSI (GET_H_GR (FLD (f_rs)), EXTHISI (TRUNCSIHI (FLD (f_imm))))));
1613     SET_H_GR (FLD (f_rt), opval);
1614     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1615   }
1616
1617   return vpc;
1618 #undef FLD
1619 }
1620
1621 /* lui: lui $rt,$hi16 */
1622
1623 static SEM_PC
1624 SEM_FN_NAME (iq2000bf,lui) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1625 {
1626 #define FLD(f) abuf->fields.sfmt_addi.f
1627   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1628   int UNUSED written = 0;
1629   IADDR UNUSED pc = abuf->addr;
1630   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1631
1632   {
1633     SI opval = SLLSI (FLD (f_imm), 16);
1634     SET_H_GR (FLD (f_rt), opval);
1635     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1636   }
1637
1638   return vpc;
1639 #undef FLD
1640 }
1641
1642 /* lw: lw $rt,$lo16($base) */
1643
1644 static SEM_PC
1645 SEM_FN_NAME (iq2000bf,lw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1646 {
1647 #define FLD(f) abuf->fields.sfmt_addi.f
1648   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1649   int UNUSED written = 0;
1650   IADDR UNUSED pc = abuf->addr;
1651   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1652
1653   {
1654     SI opval = GETMEMSI (current_cpu, pc, ADDSI (GET_H_GR (FLD (f_rs)), EXTHISI (TRUNCSIHI (FLD (f_imm)))));
1655     SET_H_GR (FLD (f_rt), opval);
1656     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1657   }
1658
1659   return vpc;
1660 #undef FLD
1661 }
1662
1663 /* sb: sb $rt,$lo16($base) */
1664
1665 static SEM_PC
1666 SEM_FN_NAME (iq2000bf,sb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1667 {
1668 #define FLD(f) abuf->fields.sfmt_addi.f
1669   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1670   int UNUSED written = 0;
1671   IADDR UNUSED pc = abuf->addr;
1672   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1673
1674   {
1675     QI opval = ANDQI (GET_H_GR (FLD (f_rt)), 255);
1676     SETMEMQI (current_cpu, pc, ADDSI (GET_H_GR (FLD (f_rs)), EXTHISI (TRUNCSIHI (FLD (f_imm)))), opval);
1677     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
1678   }
1679
1680   return vpc;
1681 #undef FLD
1682 }
1683
1684 /* sh: sh $rt,$lo16($base) */
1685
1686 static SEM_PC
1687 SEM_FN_NAME (iq2000bf,sh) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1688 {
1689 #define FLD(f) abuf->fields.sfmt_addi.f
1690   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1691   int UNUSED written = 0;
1692   IADDR UNUSED pc = abuf->addr;
1693   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1694
1695   {
1696     HI opval = ANDHI (GET_H_GR (FLD (f_rt)), 65535);
1697     SETMEMHI (current_cpu, pc, ADDSI (GET_H_GR (FLD (f_rs)), EXTHISI (TRUNCSIHI (FLD (f_imm)))), opval);
1698     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
1699   }
1700
1701   return vpc;
1702 #undef FLD
1703 }
1704
1705 /* sw: sw $rt,$lo16($base) */
1706
1707 static SEM_PC
1708 SEM_FN_NAME (iq2000bf,sw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1709 {
1710 #define FLD(f) abuf->fields.sfmt_addi.f
1711   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1712   int UNUSED written = 0;
1713   IADDR UNUSED pc = abuf->addr;
1714   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1715
1716   {
1717     SI opval = GET_H_GR (FLD (f_rt));
1718     SETMEMSI (current_cpu, pc, ADDSI (GET_H_GR (FLD (f_rs)), EXTHISI (TRUNCSIHI (FLD (f_imm)))), opval);
1719     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
1720   }
1721
1722   return vpc;
1723 #undef FLD
1724 }
1725
1726 /* break: break */
1727
1728 static SEM_PC
1729 SEM_FN_NAME (iq2000bf,break) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1730 {
1731 #define FLD(f) abuf->fields.sfmt_empty.f
1732   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1733   int UNUSED written = 0;
1734   IADDR UNUSED pc = abuf->addr;
1735   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1736
1737 do_break (current_cpu, pc);
1738
1739   return vpc;
1740 #undef FLD
1741 }
1742
1743 /* syscall: syscall */
1744
1745 static SEM_PC
1746 SEM_FN_NAME (iq2000bf,syscall) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1747 {
1748 #define FLD(f) abuf->fields.sfmt_empty.f
1749   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1750   int UNUSED written = 0;
1751   IADDR UNUSED pc = abuf->addr;
1752   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1753
1754 do_syscall (current_cpu);
1755
1756   return vpc;
1757 #undef FLD
1758 }
1759
1760 /* andoui: andoui $rt,$rs,$hi16 */
1761
1762 static SEM_PC
1763 SEM_FN_NAME (iq2000bf,andoui) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1764 {
1765 #define FLD(f) abuf->fields.sfmt_addi.f
1766   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1767   int UNUSED written = 0;
1768   IADDR UNUSED pc = abuf->addr;
1769   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1770
1771   {
1772     SI opval = ANDSI (GET_H_GR (FLD (f_rs)), ORSI (SLLSI (FLD (f_imm), 16), 65535));
1773     SET_H_GR (FLD (f_rt), opval);
1774     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1775   }
1776
1777   return vpc;
1778 #undef FLD
1779 }
1780
1781 /* orui: orui $rt,$rs,$hi16 */
1782
1783 static SEM_PC
1784 SEM_FN_NAME (iq2000bf,orui) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1785 {
1786 #define FLD(f) abuf->fields.sfmt_addi.f
1787   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1788   int UNUSED written = 0;
1789   IADDR UNUSED pc = abuf->addr;
1790   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1791
1792   {
1793     SI opval = ORSI (GET_H_GR (FLD (f_rs)), SLLSI (FLD (f_imm), 16));
1794     SET_H_GR (FLD (f_rt), opval);
1795     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1796   }
1797
1798   return vpc;
1799 #undef FLD
1800 }
1801
1802 /* bgtz: bgtz $rs,$offset */
1803
1804 static SEM_PC
1805 SEM_FN_NAME (iq2000bf,bgtz) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1806 {
1807 #define FLD(f) abuf->fields.sfmt_bbi.f
1808   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1809   int UNUSED written = 0;
1810   IADDR UNUSED pc = abuf->addr;
1811   SEM_BRANCH_INIT
1812   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1813
1814 if (GTSI (GET_H_GR (FLD (f_rs)), 0)) {
1815 {
1816   {
1817     USI opval = FLD (i_offset);
1818     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1819     written |= (1 << 2);
1820     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1821   }
1822 }
1823 }
1824
1825   abuf->written = written;
1826   SEM_BRANCH_FINI (vpc);
1827   return vpc;
1828 #undef FLD
1829 }
1830
1831 /* bgtzl: bgtzl $rs,$offset */
1832
1833 static SEM_PC
1834 SEM_FN_NAME (iq2000bf,bgtzl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1835 {
1836 #define FLD(f) abuf->fields.sfmt_bbi.f
1837   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1838   int UNUSED written = 0;
1839   IADDR UNUSED pc = abuf->addr;
1840   SEM_BRANCH_INIT
1841   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1842
1843 if (GTSI (GET_H_GR (FLD (f_rs)), 0)) {
1844 {
1845   {
1846     USI opval = FLD (i_offset);
1847     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1848     written |= (1 << 2);
1849     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1850   }
1851 }
1852 } else {
1853 if (1)
1854   SEM_SKIP_INSN (current_cpu, sem_arg, vpc);
1855 }
1856
1857   abuf->written = written;
1858   SEM_BRANCH_FINI (vpc);
1859   return vpc;
1860 #undef FLD
1861 }
1862
1863 /* blez: blez $rs,$offset */
1864
1865 static SEM_PC
1866 SEM_FN_NAME (iq2000bf,blez) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1867 {
1868 #define FLD(f) abuf->fields.sfmt_bbi.f
1869   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1870   int UNUSED written = 0;
1871   IADDR UNUSED pc = abuf->addr;
1872   SEM_BRANCH_INIT
1873   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1874
1875 if (LESI (GET_H_GR (FLD (f_rs)), 0)) {
1876 {
1877   {
1878     USI opval = FLD (i_offset);
1879     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1880     written |= (1 << 2);
1881     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1882   }
1883 }
1884 }
1885
1886   abuf->written = written;
1887   SEM_BRANCH_FINI (vpc);
1888   return vpc;
1889 #undef FLD
1890 }
1891
1892 /* blezl: blezl $rs,$offset */
1893
1894 static SEM_PC
1895 SEM_FN_NAME (iq2000bf,blezl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1896 {
1897 #define FLD(f) abuf->fields.sfmt_bbi.f
1898   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1899   int UNUSED written = 0;
1900   IADDR UNUSED pc = abuf->addr;
1901   SEM_BRANCH_INIT
1902   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1903
1904 if (LESI (GET_H_GR (FLD (f_rs)), 0)) {
1905 {
1906   {
1907     USI opval = FLD (i_offset);
1908     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1909     written |= (1 << 2);
1910     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1911   }
1912 }
1913 } else {
1914 if (1)
1915   SEM_SKIP_INSN (current_cpu, sem_arg, vpc);
1916 }
1917
1918   abuf->written = written;
1919   SEM_BRANCH_FINI (vpc);
1920   return vpc;
1921 #undef FLD
1922 }
1923
1924 /* mrgb: mrgb $rd,$rs,$rt,$mask */
1925
1926 static SEM_PC
1927 SEM_FN_NAME (iq2000bf,mrgb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1928 {
1929 #define FLD(f) abuf->fields.sfmt_mrgb.f
1930   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1931   int UNUSED written = 0;
1932   IADDR UNUSED pc = abuf->addr;
1933   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1934
1935 {
1936   SI tmp_temp;
1937 if (NOTSI (ANDSI (FLD (f_mask), SLLSI (1, 0)))) {
1938   tmp_temp = ANDSI (GET_H_GR (FLD (f_rs)), 255);
1939 } else {
1940   tmp_temp = ANDSI (GET_H_GR (FLD (f_rt)), 255);
1941 }
1942 if (NOTSI (ANDSI (FLD (f_mask), SLLSI (1, 1)))) {
1943   tmp_temp = ORSI (tmp_temp, ANDSI (GET_H_GR (FLD (f_rs)), 65280));
1944 } else {
1945   tmp_temp = ORSI (tmp_temp, ANDSI (GET_H_GR (FLD (f_rt)), 65280));
1946 }
1947 if (NOTSI (ANDSI (FLD (f_mask), SLLSI (1, 2)))) {
1948   tmp_temp = ORSI (tmp_temp, ANDSI (GET_H_GR (FLD (f_rs)), 16711680));
1949 } else {
1950   tmp_temp = ORSI (tmp_temp, ANDSI (GET_H_GR (FLD (f_rt)), 16711680));
1951 }
1952 if (NOTSI (ANDSI (FLD (f_mask), SLLSI (1, 3)))) {
1953   tmp_temp = ORSI (tmp_temp, ANDSI (GET_H_GR (FLD (f_rs)), 0xff000000));
1954 } else {
1955   tmp_temp = ORSI (tmp_temp, ANDSI (GET_H_GR (FLD (f_rt)), 0xff000000));
1956 }
1957   {
1958     SI opval = tmp_temp;
1959     SET_H_GR (FLD (f_rd), opval);
1960     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1961   }
1962 }
1963
1964   return vpc;
1965 #undef FLD
1966 }
1967
1968 /* bctxt: bctxt $rs,$offset */
1969
1970 static SEM_PC
1971 SEM_FN_NAME (iq2000bf,bctxt) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1972 {
1973 #define FLD(f) abuf->fields.sfmt_empty.f
1974   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1975   int UNUSED written = 0;
1976   IADDR UNUSED pc = abuf->addr;
1977   SEM_BRANCH_INIT
1978   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1979
1980 ((void) 0); /*nop*/
1981
1982   SEM_BRANCH_FINI (vpc);
1983   return vpc;
1984 #undef FLD
1985 }
1986
1987 /* bc0f: bc0f $offset */
1988
1989 static SEM_PC
1990 SEM_FN_NAME (iq2000bf,bc0f) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
1991 {
1992 #define FLD(f) abuf->fields.sfmt_empty.f
1993   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1994   int UNUSED written = 0;
1995   IADDR UNUSED pc = abuf->addr;
1996   SEM_BRANCH_INIT
1997   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1998
1999 ((void) 0); /*nop*/
2000
2001   SEM_BRANCH_FINI (vpc);
2002   return vpc;
2003 #undef FLD
2004 }
2005
2006 /* bc0fl: bc0fl $offset */
2007
2008 static SEM_PC
2009 SEM_FN_NAME (iq2000bf,bc0fl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2010 {
2011 #define FLD(f) abuf->fields.sfmt_empty.f
2012   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2013   int UNUSED written = 0;
2014   IADDR UNUSED pc = abuf->addr;
2015   SEM_BRANCH_INIT
2016   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2017
2018 ((void) 0); /*nop*/
2019
2020   SEM_BRANCH_FINI (vpc);
2021   return vpc;
2022 #undef FLD
2023 }
2024
2025 /* bc3f: bc3f $offset */
2026
2027 static SEM_PC
2028 SEM_FN_NAME (iq2000bf,bc3f) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2029 {
2030 #define FLD(f) abuf->fields.sfmt_empty.f
2031   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2032   int UNUSED written = 0;
2033   IADDR UNUSED pc = abuf->addr;
2034   SEM_BRANCH_INIT
2035   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2036
2037 ((void) 0); /*nop*/
2038
2039   SEM_BRANCH_FINI (vpc);
2040   return vpc;
2041 #undef FLD
2042 }
2043
2044 /* bc3fl: bc3fl $offset */
2045
2046 static SEM_PC
2047 SEM_FN_NAME (iq2000bf,bc3fl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2048 {
2049 #define FLD(f) abuf->fields.sfmt_empty.f
2050   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2051   int UNUSED written = 0;
2052   IADDR UNUSED pc = abuf->addr;
2053   SEM_BRANCH_INIT
2054   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2055
2056 ((void) 0); /*nop*/
2057
2058   SEM_BRANCH_FINI (vpc);
2059   return vpc;
2060 #undef FLD
2061 }
2062
2063 /* bc0t: bc0t $offset */
2064
2065 static SEM_PC
2066 SEM_FN_NAME (iq2000bf,bc0t) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2067 {
2068 #define FLD(f) abuf->fields.sfmt_empty.f
2069   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2070   int UNUSED written = 0;
2071   IADDR UNUSED pc = abuf->addr;
2072   SEM_BRANCH_INIT
2073   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2074
2075 ((void) 0); /*nop*/
2076
2077   SEM_BRANCH_FINI (vpc);
2078   return vpc;
2079 #undef FLD
2080 }
2081
2082 /* bc0tl: bc0tl $offset */
2083
2084 static SEM_PC
2085 SEM_FN_NAME (iq2000bf,bc0tl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2086 {
2087 #define FLD(f) abuf->fields.sfmt_empty.f
2088   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2089   int UNUSED written = 0;
2090   IADDR UNUSED pc = abuf->addr;
2091   SEM_BRANCH_INIT
2092   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2093
2094 ((void) 0); /*nop*/
2095
2096   SEM_BRANCH_FINI (vpc);
2097   return vpc;
2098 #undef FLD
2099 }
2100
2101 /* bc3t: bc3t $offset */
2102
2103 static SEM_PC
2104 SEM_FN_NAME (iq2000bf,bc3t) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2105 {
2106 #define FLD(f) abuf->fields.sfmt_empty.f
2107   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2108   int UNUSED written = 0;
2109   IADDR UNUSED pc = abuf->addr;
2110   SEM_BRANCH_INIT
2111   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2112
2113 ((void) 0); /*nop*/
2114
2115   SEM_BRANCH_FINI (vpc);
2116   return vpc;
2117 #undef FLD
2118 }
2119
2120 /* bc3tl: bc3tl $offset */
2121
2122 static SEM_PC
2123 SEM_FN_NAME (iq2000bf,bc3tl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2124 {
2125 #define FLD(f) abuf->fields.sfmt_empty.f
2126   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2127   int UNUSED written = 0;
2128   IADDR UNUSED pc = abuf->addr;
2129   SEM_BRANCH_INIT
2130   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2131
2132 ((void) 0); /*nop*/
2133
2134   SEM_BRANCH_FINI (vpc);
2135   return vpc;
2136 #undef FLD
2137 }
2138
2139 /* cfc0: cfc0 $rt,$rd */
2140
2141 static SEM_PC
2142 SEM_FN_NAME (iq2000bf,cfc0) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2143 {
2144 #define FLD(f) abuf->fields.sfmt_empty.f
2145   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2146   int UNUSED written = 0;
2147   IADDR UNUSED pc = abuf->addr;
2148   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2149
2150 ((void) 0); /*nop*/
2151
2152   return vpc;
2153 #undef FLD
2154 }
2155
2156 /* cfc1: cfc1 $rt,$rd */
2157
2158 static SEM_PC
2159 SEM_FN_NAME (iq2000bf,cfc1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2160 {
2161 #define FLD(f) abuf->fields.sfmt_empty.f
2162   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2163   int UNUSED written = 0;
2164   IADDR UNUSED pc = abuf->addr;
2165   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2166
2167 ((void) 0); /*nop*/
2168
2169   return vpc;
2170 #undef FLD
2171 }
2172
2173 /* cfc2: cfc2 $rt,$rd */
2174
2175 static SEM_PC
2176 SEM_FN_NAME (iq2000bf,cfc2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2177 {
2178 #define FLD(f) abuf->fields.sfmt_empty.f
2179   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2180   int UNUSED written = 0;
2181   IADDR UNUSED pc = abuf->addr;
2182   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2183
2184 ((void) 0); /*nop*/
2185
2186   return vpc;
2187 #undef FLD
2188 }
2189
2190 /* cfc3: cfc3 $rt,$rd */
2191
2192 static SEM_PC
2193 SEM_FN_NAME (iq2000bf,cfc3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2194 {
2195 #define FLD(f) abuf->fields.sfmt_empty.f
2196   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2197   int UNUSED written = 0;
2198   IADDR UNUSED pc = abuf->addr;
2199   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2200
2201 ((void) 0); /*nop*/
2202
2203   return vpc;
2204 #undef FLD
2205 }
2206
2207 /* chkhdr: chkhdr $rd,$rt */
2208
2209 static SEM_PC
2210 SEM_FN_NAME (iq2000bf,chkhdr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2211 {
2212 #define FLD(f) abuf->fields.sfmt_empty.f
2213   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2214   int UNUSED written = 0;
2215   IADDR UNUSED pc = abuf->addr;
2216   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2217
2218 ((void) 0); /*nop*/
2219
2220   return vpc;
2221 #undef FLD
2222 }
2223
2224 /* ctc0: ctc0 $rt,$rd */
2225
2226 static SEM_PC
2227 SEM_FN_NAME (iq2000bf,ctc0) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2228 {
2229 #define FLD(f) abuf->fields.sfmt_empty.f
2230   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2231   int UNUSED written = 0;
2232   IADDR UNUSED pc = abuf->addr;
2233   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2234
2235 ((void) 0); /*nop*/
2236
2237   return vpc;
2238 #undef FLD
2239 }
2240
2241 /* ctc1: ctc1 $rt,$rd */
2242
2243 static SEM_PC
2244 SEM_FN_NAME (iq2000bf,ctc1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2245 {
2246 #define FLD(f) abuf->fields.sfmt_empty.f
2247   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2248   int UNUSED written = 0;
2249   IADDR UNUSED pc = abuf->addr;
2250   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2251
2252 ((void) 0); /*nop*/
2253
2254   return vpc;
2255 #undef FLD
2256 }
2257
2258 /* ctc2: ctc2 $rt,$rd */
2259
2260 static SEM_PC
2261 SEM_FN_NAME (iq2000bf,ctc2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2262 {
2263 #define FLD(f) abuf->fields.sfmt_empty.f
2264   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2265   int UNUSED written = 0;
2266   IADDR UNUSED pc = abuf->addr;
2267   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2268
2269 ((void) 0); /*nop*/
2270
2271   return vpc;
2272 #undef FLD
2273 }
2274
2275 /* ctc3: ctc3 $rt,$rd */
2276
2277 static SEM_PC
2278 SEM_FN_NAME (iq2000bf,ctc3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2279 {
2280 #define FLD(f) abuf->fields.sfmt_empty.f
2281   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2282   int UNUSED written = 0;
2283   IADDR UNUSED pc = abuf->addr;
2284   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2285
2286 ((void) 0); /*nop*/
2287
2288   return vpc;
2289 #undef FLD
2290 }
2291
2292 /* jcr: jcr $rs */
2293
2294 static SEM_PC
2295 SEM_FN_NAME (iq2000bf,jcr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2296 {
2297 #define FLD(f) abuf->fields.sfmt_empty.f
2298   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2299   int UNUSED written = 0;
2300   IADDR UNUSED pc = abuf->addr;
2301   SEM_BRANCH_INIT
2302   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2303
2304 ((void) 0); /*nop*/
2305
2306   SEM_BRANCH_FINI (vpc);
2307   return vpc;
2308 #undef FLD
2309 }
2310
2311 /* luc32: luc32 $rt,$rd */
2312
2313 static SEM_PC
2314 SEM_FN_NAME (iq2000bf,luc32) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2315 {
2316 #define FLD(f) abuf->fields.sfmt_empty.f
2317   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2318   int UNUSED written = 0;
2319   IADDR UNUSED pc = abuf->addr;
2320   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2321
2322 ((void) 0); /*nop*/
2323
2324   return vpc;
2325 #undef FLD
2326 }
2327
2328 /* luc32l: luc32l $rt,$rd */
2329
2330 static SEM_PC
2331 SEM_FN_NAME (iq2000bf,luc32l) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2332 {
2333 #define FLD(f) abuf->fields.sfmt_empty.f
2334   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2335   int UNUSED written = 0;
2336   IADDR UNUSED pc = abuf->addr;
2337   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2338
2339 ((void) 0); /*nop*/
2340
2341   return vpc;
2342 #undef FLD
2343 }
2344
2345 /* luc64: luc64 $rt,$rd */
2346
2347 static SEM_PC
2348 SEM_FN_NAME (iq2000bf,luc64) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2349 {
2350 #define FLD(f) abuf->fields.sfmt_empty.f
2351   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2352   int UNUSED written = 0;
2353   IADDR UNUSED pc = abuf->addr;
2354   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2355
2356 ((void) 0); /*nop*/
2357
2358   return vpc;
2359 #undef FLD
2360 }
2361
2362 /* luc64l: luc64l $rt,$rd */
2363
2364 static SEM_PC
2365 SEM_FN_NAME (iq2000bf,luc64l) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2366 {
2367 #define FLD(f) abuf->fields.sfmt_empty.f
2368   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2369   int UNUSED written = 0;
2370   IADDR UNUSED pc = abuf->addr;
2371   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2372
2373 ((void) 0); /*nop*/
2374
2375   return vpc;
2376 #undef FLD
2377 }
2378
2379 /* luk: luk $rt,$rd */
2380
2381 static SEM_PC
2382 SEM_FN_NAME (iq2000bf,luk) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2383 {
2384 #define FLD(f) abuf->fields.sfmt_empty.f
2385   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2386   int UNUSED written = 0;
2387   IADDR UNUSED pc = abuf->addr;
2388   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2389
2390 ((void) 0); /*nop*/
2391
2392   return vpc;
2393 #undef FLD
2394 }
2395
2396 /* lulck: lulck $rt */
2397
2398 static SEM_PC
2399 SEM_FN_NAME (iq2000bf,lulck) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2400 {
2401 #define FLD(f) abuf->fields.sfmt_empty.f
2402   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2403   int UNUSED written = 0;
2404   IADDR UNUSED pc = abuf->addr;
2405   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2406
2407 ((void) 0); /*nop*/
2408
2409   return vpc;
2410 #undef FLD
2411 }
2412
2413 /* lum32: lum32 $rt,$rd */
2414
2415 static SEM_PC
2416 SEM_FN_NAME (iq2000bf,lum32) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2417 {
2418 #define FLD(f) abuf->fields.sfmt_empty.f
2419   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2420   int UNUSED written = 0;
2421   IADDR UNUSED pc = abuf->addr;
2422   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2423
2424 ((void) 0); /*nop*/
2425
2426   return vpc;
2427 #undef FLD
2428 }
2429
2430 /* lum32l: lum32l $rt,$rd */
2431
2432 static SEM_PC
2433 SEM_FN_NAME (iq2000bf,lum32l) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2434 {
2435 #define FLD(f) abuf->fields.sfmt_empty.f
2436   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2437   int UNUSED written = 0;
2438   IADDR UNUSED pc = abuf->addr;
2439   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2440
2441 ((void) 0); /*nop*/
2442
2443   return vpc;
2444 #undef FLD
2445 }
2446
2447 /* lum64: lum64 $rt,$rd */
2448
2449 static SEM_PC
2450 SEM_FN_NAME (iq2000bf,lum64) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2451 {
2452 #define FLD(f) abuf->fields.sfmt_empty.f
2453   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2454   int UNUSED written = 0;
2455   IADDR UNUSED pc = abuf->addr;
2456   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2457
2458 ((void) 0); /*nop*/
2459
2460   return vpc;
2461 #undef FLD
2462 }
2463
2464 /* lum64l: lum64l $rt,$rd */
2465
2466 static SEM_PC
2467 SEM_FN_NAME (iq2000bf,lum64l) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2468 {
2469 #define FLD(f) abuf->fields.sfmt_empty.f
2470   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2471   int UNUSED written = 0;
2472   IADDR UNUSED pc = abuf->addr;
2473   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2474
2475 ((void) 0); /*nop*/
2476
2477   return vpc;
2478 #undef FLD
2479 }
2480
2481 /* lur: lur $rt,$rd */
2482
2483 static SEM_PC
2484 SEM_FN_NAME (iq2000bf,lur) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2485 {
2486 #define FLD(f) abuf->fields.sfmt_empty.f
2487   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2488   int UNUSED written = 0;
2489   IADDR UNUSED pc = abuf->addr;
2490   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2491
2492 ((void) 0); /*nop*/
2493
2494   return vpc;
2495 #undef FLD
2496 }
2497
2498 /* lurl: lurl $rt,$rd */
2499
2500 static SEM_PC
2501 SEM_FN_NAME (iq2000bf,lurl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2502 {
2503 #define FLD(f) abuf->fields.sfmt_empty.f
2504   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2505   int UNUSED written = 0;
2506   IADDR UNUSED pc = abuf->addr;
2507   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2508
2509 ((void) 0); /*nop*/
2510
2511   return vpc;
2512 #undef FLD
2513 }
2514
2515 /* luulck: luulck $rt */
2516
2517 static SEM_PC
2518 SEM_FN_NAME (iq2000bf,luulck) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2519 {
2520 #define FLD(f) abuf->fields.sfmt_empty.f
2521   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2522   int UNUSED written = 0;
2523   IADDR UNUSED pc = abuf->addr;
2524   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2525
2526 ((void) 0); /*nop*/
2527
2528   return vpc;
2529 #undef FLD
2530 }
2531
2532 /* mfc0: mfc0 $rt,$rd */
2533
2534 static SEM_PC
2535 SEM_FN_NAME (iq2000bf,mfc0) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2536 {
2537 #define FLD(f) abuf->fields.sfmt_empty.f
2538   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2539   int UNUSED written = 0;
2540   IADDR UNUSED pc = abuf->addr;
2541   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2542
2543 ((void) 0); /*nop*/
2544
2545   return vpc;
2546 #undef FLD
2547 }
2548
2549 /* mfc1: mfc1 $rt,$rd */
2550
2551 static SEM_PC
2552 SEM_FN_NAME (iq2000bf,mfc1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2553 {
2554 #define FLD(f) abuf->fields.sfmt_empty.f
2555   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2556   int UNUSED written = 0;
2557   IADDR UNUSED pc = abuf->addr;
2558   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2559
2560 ((void) 0); /*nop*/
2561
2562   return vpc;
2563 #undef FLD
2564 }
2565
2566 /* mfc2: mfc2 $rt,$rd */
2567
2568 static SEM_PC
2569 SEM_FN_NAME (iq2000bf,mfc2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2570 {
2571 #define FLD(f) abuf->fields.sfmt_empty.f
2572   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2573   int UNUSED written = 0;
2574   IADDR UNUSED pc = abuf->addr;
2575   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2576
2577 ((void) 0); /*nop*/
2578
2579   return vpc;
2580 #undef FLD
2581 }
2582
2583 /* mfc3: mfc3 $rt,$rd */
2584
2585 static SEM_PC
2586 SEM_FN_NAME (iq2000bf,mfc3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2587 {
2588 #define FLD(f) abuf->fields.sfmt_empty.f
2589   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2590   int UNUSED written = 0;
2591   IADDR UNUSED pc = abuf->addr;
2592   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2593
2594 ((void) 0); /*nop*/
2595
2596   return vpc;
2597 #undef FLD
2598 }
2599
2600 /* mtc0: mtc0 $rt,$rd */
2601
2602 static SEM_PC
2603 SEM_FN_NAME (iq2000bf,mtc0) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2604 {
2605 #define FLD(f) abuf->fields.sfmt_empty.f
2606   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2607   int UNUSED written = 0;
2608   IADDR UNUSED pc = abuf->addr;
2609   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2610
2611 ((void) 0); /*nop*/
2612
2613   return vpc;
2614 #undef FLD
2615 }
2616
2617 /* mtc1: mtc1 $rt,$rd */
2618
2619 static SEM_PC
2620 SEM_FN_NAME (iq2000bf,mtc1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2621 {
2622 #define FLD(f) abuf->fields.sfmt_empty.f
2623   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2624   int UNUSED written = 0;
2625   IADDR UNUSED pc = abuf->addr;
2626   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2627
2628 ((void) 0); /*nop*/
2629
2630   return vpc;
2631 #undef FLD
2632 }
2633
2634 /* mtc2: mtc2 $rt,$rd */
2635
2636 static SEM_PC
2637 SEM_FN_NAME (iq2000bf,mtc2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2638 {
2639 #define FLD(f) abuf->fields.sfmt_empty.f
2640   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2641   int UNUSED written = 0;
2642   IADDR UNUSED pc = abuf->addr;
2643   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2644
2645 ((void) 0); /*nop*/
2646
2647   return vpc;
2648 #undef FLD
2649 }
2650
2651 /* mtc3: mtc3 $rt,$rd */
2652
2653 static SEM_PC
2654 SEM_FN_NAME (iq2000bf,mtc3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2655 {
2656 #define FLD(f) abuf->fields.sfmt_empty.f
2657   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2658   int UNUSED written = 0;
2659   IADDR UNUSED pc = abuf->addr;
2660   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2661
2662 ((void) 0); /*nop*/
2663
2664   return vpc;
2665 #undef FLD
2666 }
2667
2668 /* pkrl: pkrl $rd,$rt */
2669
2670 static SEM_PC
2671 SEM_FN_NAME (iq2000bf,pkrl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2672 {
2673 #define FLD(f) abuf->fields.sfmt_empty.f
2674   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2675   int UNUSED written = 0;
2676   IADDR UNUSED pc = abuf->addr;
2677   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2678
2679 ((void) 0); /*nop*/
2680
2681   return vpc;
2682 #undef FLD
2683 }
2684
2685 /* pkrlr1: pkrlr1 $rt,$_index,$count */
2686
2687 static SEM_PC
2688 SEM_FN_NAME (iq2000bf,pkrlr1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2689 {
2690 #define FLD(f) abuf->fields.sfmt_empty.f
2691   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2692   int UNUSED written = 0;
2693   IADDR UNUSED pc = abuf->addr;
2694   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2695
2696 ((void) 0); /*nop*/
2697
2698   return vpc;
2699 #undef FLD
2700 }
2701
2702 /* pkrlr30: pkrlr30 $rt,$_index,$count */
2703
2704 static SEM_PC
2705 SEM_FN_NAME (iq2000bf,pkrlr30) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2706 {
2707 #define FLD(f) abuf->fields.sfmt_empty.f
2708   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2709   int UNUSED written = 0;
2710   IADDR UNUSED pc = abuf->addr;
2711   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2712
2713 ((void) 0); /*nop*/
2714
2715   return vpc;
2716 #undef FLD
2717 }
2718
2719 /* rb: rb $rd,$rt */
2720
2721 static SEM_PC
2722 SEM_FN_NAME (iq2000bf,rb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2723 {
2724 #define FLD(f) abuf->fields.sfmt_empty.f
2725   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2726   int UNUSED written = 0;
2727   IADDR UNUSED pc = abuf->addr;
2728   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2729
2730 ((void) 0); /*nop*/
2731
2732   return vpc;
2733 #undef FLD
2734 }
2735
2736 /* rbr1: rbr1 $rt,$_index,$count */
2737
2738 static SEM_PC
2739 SEM_FN_NAME (iq2000bf,rbr1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2740 {
2741 #define FLD(f) abuf->fields.sfmt_empty.f
2742   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2743   int UNUSED written = 0;
2744   IADDR UNUSED pc = abuf->addr;
2745   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2746
2747 ((void) 0); /*nop*/
2748
2749   return vpc;
2750 #undef FLD
2751 }
2752
2753 /* rbr30: rbr30 $rt,$_index,$count */
2754
2755 static SEM_PC
2756 SEM_FN_NAME (iq2000bf,rbr30) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2757 {
2758 #define FLD(f) abuf->fields.sfmt_empty.f
2759   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2760   int UNUSED written = 0;
2761   IADDR UNUSED pc = abuf->addr;
2762   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2763
2764 ((void) 0); /*nop*/
2765
2766   return vpc;
2767 #undef FLD
2768 }
2769
2770 /* rfe: rfe */
2771
2772 static SEM_PC
2773 SEM_FN_NAME (iq2000bf,rfe) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2774 {
2775 #define FLD(f) abuf->fields.sfmt_empty.f
2776   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2777   int UNUSED written = 0;
2778   IADDR UNUSED pc = abuf->addr;
2779   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2780
2781 ((void) 0); /*nop*/
2782
2783   return vpc;
2784 #undef FLD
2785 }
2786
2787 /* rx: rx $rd,$rt */
2788
2789 static SEM_PC
2790 SEM_FN_NAME (iq2000bf,rx) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2791 {
2792 #define FLD(f) abuf->fields.sfmt_empty.f
2793   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2794   int UNUSED written = 0;
2795   IADDR UNUSED pc = abuf->addr;
2796   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2797
2798 ((void) 0); /*nop*/
2799
2800   return vpc;
2801 #undef FLD
2802 }
2803
2804 /* rxr1: rxr1 $rt,$_index,$count */
2805
2806 static SEM_PC
2807 SEM_FN_NAME (iq2000bf,rxr1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2808 {
2809 #define FLD(f) abuf->fields.sfmt_empty.f
2810   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2811   int UNUSED written = 0;
2812   IADDR UNUSED pc = abuf->addr;
2813   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2814
2815 ((void) 0); /*nop*/
2816
2817   return vpc;
2818 #undef FLD
2819 }
2820
2821 /* rxr30: rxr30 $rt,$_index,$count */
2822
2823 static SEM_PC
2824 SEM_FN_NAME (iq2000bf,rxr30) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2825 {
2826 #define FLD(f) abuf->fields.sfmt_empty.f
2827   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2828   int UNUSED written = 0;
2829   IADDR UNUSED pc = abuf->addr;
2830   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2831
2832 ((void) 0); /*nop*/
2833
2834   return vpc;
2835 #undef FLD
2836 }
2837
2838 /* sleep: sleep */
2839
2840 static SEM_PC
2841 SEM_FN_NAME (iq2000bf,sleep) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2842 {
2843 #define FLD(f) abuf->fields.sfmt_empty.f
2844   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2845   int UNUSED written = 0;
2846   IADDR UNUSED pc = abuf->addr;
2847   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2848
2849 ((void) 0); /*nop*/
2850
2851   return vpc;
2852 #undef FLD
2853 }
2854
2855 /* srrd: srrd $rt */
2856
2857 static SEM_PC
2858 SEM_FN_NAME (iq2000bf,srrd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2859 {
2860 #define FLD(f) abuf->fields.sfmt_empty.f
2861   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2862   int UNUSED written = 0;
2863   IADDR UNUSED pc = abuf->addr;
2864   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2865
2866 ((void) 0); /*nop*/
2867
2868   return vpc;
2869 #undef FLD
2870 }
2871
2872 /* srrdl: srrdl $rt */
2873
2874 static SEM_PC
2875 SEM_FN_NAME (iq2000bf,srrdl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2876 {
2877 #define FLD(f) abuf->fields.sfmt_empty.f
2878   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2879   int UNUSED written = 0;
2880   IADDR UNUSED pc = abuf->addr;
2881   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2882
2883 ((void) 0); /*nop*/
2884
2885   return vpc;
2886 #undef FLD
2887 }
2888
2889 /* srulck: srulck $rt */
2890
2891 static SEM_PC
2892 SEM_FN_NAME (iq2000bf,srulck) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2893 {
2894 #define FLD(f) abuf->fields.sfmt_empty.f
2895   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2896   int UNUSED written = 0;
2897   IADDR UNUSED pc = abuf->addr;
2898   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2899
2900 ((void) 0); /*nop*/
2901
2902   return vpc;
2903 #undef FLD
2904 }
2905
2906 /* srwr: srwr $rt,$rd */
2907
2908 static SEM_PC
2909 SEM_FN_NAME (iq2000bf,srwr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2910 {
2911 #define FLD(f) abuf->fields.sfmt_empty.f
2912   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2913   int UNUSED written = 0;
2914   IADDR UNUSED pc = abuf->addr;
2915   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2916
2917 ((void) 0); /*nop*/
2918
2919   return vpc;
2920 #undef FLD
2921 }
2922
2923 /* srwru: srwru $rt,$rd */
2924
2925 static SEM_PC
2926 SEM_FN_NAME (iq2000bf,srwru) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2927 {
2928 #define FLD(f) abuf->fields.sfmt_empty.f
2929   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2930   int UNUSED written = 0;
2931   IADDR UNUSED pc = abuf->addr;
2932   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2933
2934 ((void) 0); /*nop*/
2935
2936   return vpc;
2937 #undef FLD
2938 }
2939
2940 /* trapqfl: trapqfl */
2941
2942 static SEM_PC
2943 SEM_FN_NAME (iq2000bf,trapqfl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2944 {
2945 #define FLD(f) abuf->fields.sfmt_empty.f
2946   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2947   int UNUSED written = 0;
2948   IADDR UNUSED pc = abuf->addr;
2949   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2950
2951 ((void) 0); /*nop*/
2952
2953   return vpc;
2954 #undef FLD
2955 }
2956
2957 /* trapqne: trapqne */
2958
2959 static SEM_PC
2960 SEM_FN_NAME (iq2000bf,trapqne) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2961 {
2962 #define FLD(f) abuf->fields.sfmt_empty.f
2963   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2964   int UNUSED written = 0;
2965   IADDR UNUSED pc = abuf->addr;
2966   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2967
2968 ((void) 0); /*nop*/
2969
2970   return vpc;
2971 #undef FLD
2972 }
2973
2974 /* traprel: traprel $rt */
2975
2976 static SEM_PC
2977 SEM_FN_NAME (iq2000bf,traprel) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2978 {
2979 #define FLD(f) abuf->fields.sfmt_empty.f
2980   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2981   int UNUSED written = 0;
2982   IADDR UNUSED pc = abuf->addr;
2983   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2984
2985 ((void) 0); /*nop*/
2986
2987   return vpc;
2988 #undef FLD
2989 }
2990
2991 /* wb: wb $rd,$rt */
2992
2993 static SEM_PC
2994 SEM_FN_NAME (iq2000bf,wb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
2995 {
2996 #define FLD(f) abuf->fields.sfmt_empty.f
2997   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2998   int UNUSED written = 0;
2999   IADDR UNUSED pc = abuf->addr;
3000   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3001
3002 ((void) 0); /*nop*/
3003
3004   return vpc;
3005 #undef FLD
3006 }
3007
3008 /* wbu: wbu $rd,$rt */
3009
3010 static SEM_PC
3011 SEM_FN_NAME (iq2000bf,wbu) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3012 {
3013 #define FLD(f) abuf->fields.sfmt_empty.f
3014   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3015   int UNUSED written = 0;
3016   IADDR UNUSED pc = abuf->addr;
3017   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3018
3019 ((void) 0); /*nop*/
3020
3021   return vpc;
3022 #undef FLD
3023 }
3024
3025 /* wbr1: wbr1 $rt,$_index,$count */
3026
3027 static SEM_PC
3028 SEM_FN_NAME (iq2000bf,wbr1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3029 {
3030 #define FLD(f) abuf->fields.sfmt_empty.f
3031   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3032   int UNUSED written = 0;
3033   IADDR UNUSED pc = abuf->addr;
3034   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3035
3036 ((void) 0); /*nop*/
3037
3038   return vpc;
3039 #undef FLD
3040 }
3041
3042 /* wbr1u: wbr1u $rt,$_index,$count */
3043
3044 static SEM_PC
3045 SEM_FN_NAME (iq2000bf,wbr1u) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3046 {
3047 #define FLD(f) abuf->fields.sfmt_empty.f
3048   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3049   int UNUSED written = 0;
3050   IADDR UNUSED pc = abuf->addr;
3051   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3052
3053 ((void) 0); /*nop*/
3054
3055   return vpc;
3056 #undef FLD
3057 }
3058
3059 /* wbr30: wbr30 $rt,$_index,$count */
3060
3061 static SEM_PC
3062 SEM_FN_NAME (iq2000bf,wbr30) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3063 {
3064 #define FLD(f) abuf->fields.sfmt_empty.f
3065   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3066   int UNUSED written = 0;
3067   IADDR UNUSED pc = abuf->addr;
3068   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3069
3070 ((void) 0); /*nop*/
3071
3072   return vpc;
3073 #undef FLD
3074 }
3075
3076 /* wbr30u: wbr30u $rt,$_index,$count */
3077
3078 static SEM_PC
3079 SEM_FN_NAME (iq2000bf,wbr30u) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3080 {
3081 #define FLD(f) abuf->fields.sfmt_empty.f
3082   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3083   int UNUSED written = 0;
3084   IADDR UNUSED pc = abuf->addr;
3085   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3086
3087 ((void) 0); /*nop*/
3088
3089   return vpc;
3090 #undef FLD
3091 }
3092
3093 /* wx: wx $rd,$rt */
3094
3095 static SEM_PC
3096 SEM_FN_NAME (iq2000bf,wx) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3097 {
3098 #define FLD(f) abuf->fields.sfmt_empty.f
3099   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3100   int UNUSED written = 0;
3101   IADDR UNUSED pc = abuf->addr;
3102   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3103
3104 ((void) 0); /*nop*/
3105
3106   return vpc;
3107 #undef FLD
3108 }
3109
3110 /* wxu: wxu $rd,$rt */
3111
3112 static SEM_PC
3113 SEM_FN_NAME (iq2000bf,wxu) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3114 {
3115 #define FLD(f) abuf->fields.sfmt_empty.f
3116   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3117   int UNUSED written = 0;
3118   IADDR UNUSED pc = abuf->addr;
3119   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3120
3121 ((void) 0); /*nop*/
3122
3123   return vpc;
3124 #undef FLD
3125 }
3126
3127 /* wxr1: wxr1 $rt,$_index,$count */
3128
3129 static SEM_PC
3130 SEM_FN_NAME (iq2000bf,wxr1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3131 {
3132 #define FLD(f) abuf->fields.sfmt_empty.f
3133   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3134   int UNUSED written = 0;
3135   IADDR UNUSED pc = abuf->addr;
3136   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3137
3138 ((void) 0); /*nop*/
3139
3140   return vpc;
3141 #undef FLD
3142 }
3143
3144 /* wxr1u: wxr1u $rt,$_index,$count */
3145
3146 static SEM_PC
3147 SEM_FN_NAME (iq2000bf,wxr1u) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3148 {
3149 #define FLD(f) abuf->fields.sfmt_empty.f
3150   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3151   int UNUSED written = 0;
3152   IADDR UNUSED pc = abuf->addr;
3153   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3154
3155 ((void) 0); /*nop*/
3156
3157   return vpc;
3158 #undef FLD
3159 }
3160
3161 /* wxr30: wxr30 $rt,$_index,$count */
3162
3163 static SEM_PC
3164 SEM_FN_NAME (iq2000bf,wxr30) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3165 {
3166 #define FLD(f) abuf->fields.sfmt_empty.f
3167   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3168   int UNUSED written = 0;
3169   IADDR UNUSED pc = abuf->addr;
3170   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3171
3172 ((void) 0); /*nop*/
3173
3174   return vpc;
3175 #undef FLD
3176 }
3177
3178 /* wxr30u: wxr30u $rt,$_index,$count */
3179
3180 static SEM_PC
3181 SEM_FN_NAME (iq2000bf,wxr30u) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3182 {
3183 #define FLD(f) abuf->fields.sfmt_empty.f
3184   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3185   int UNUSED written = 0;
3186   IADDR UNUSED pc = abuf->addr;
3187   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3188
3189 ((void) 0); /*nop*/
3190
3191   return vpc;
3192 #undef FLD
3193 }
3194
3195 /* ldw: ldw $rt,$lo16($base) */
3196
3197 static SEM_PC
3198 SEM_FN_NAME (iq2000bf,ldw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3199 {
3200 #define FLD(f) abuf->fields.sfmt_addi.f
3201   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3202   int UNUSED written = 0;
3203   IADDR UNUSED pc = abuf->addr;
3204   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3205
3206 {
3207   SI tmp_addr;
3208   tmp_addr = ANDSI (ADDSI (GET_H_GR (FLD (f_rs)), FLD (f_imm)), INVSI (3));
3209   {
3210     SI opval = GETMEMSI (current_cpu, pc, tmp_addr);
3211     SET_H_GR (ADDSI (FLD (f_rt), 1), opval);
3212     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3213   }
3214   {
3215     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_addr, 4));
3216     SET_H_GR (FLD (f_rt), opval);
3217     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3218   }
3219 }
3220
3221   return vpc;
3222 #undef FLD
3223 }
3224
3225 /* sdw: sdw $rt,$lo16($base) */
3226
3227 static SEM_PC
3228 SEM_FN_NAME (iq2000bf,sdw) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3229 {
3230 #define FLD(f) abuf->fields.sfmt_addi.f
3231   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3232   int UNUSED written = 0;
3233   IADDR UNUSED pc = abuf->addr;
3234   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3235
3236 {
3237   SI tmp_addr;
3238   tmp_addr = ANDSI (ADDSI (GET_H_GR (FLD (f_rs)), FLD (f_imm)), INVSI (3));
3239   {
3240     SI opval = GET_H_GR (FLD (f_rt));
3241     SETMEMSI (current_cpu, pc, ADDSI (tmp_addr, 4), opval);
3242     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
3243   }
3244   {
3245     SI opval = GET_H_GR (ADDSI (FLD (f_rt), 1));
3246     SETMEMSI (current_cpu, pc, tmp_addr, opval);
3247     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
3248   }
3249 }
3250
3251   return vpc;
3252 #undef FLD
3253 }
3254
3255 /* j: j $jmptarg */
3256
3257 static SEM_PC
3258 SEM_FN_NAME (iq2000bf,j) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3259 {
3260 #define FLD(f) abuf->fields.sfmt_j.f
3261   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3262   int UNUSED written = 0;
3263   IADDR UNUSED pc = abuf->addr;
3264   SEM_BRANCH_INIT
3265   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3266
3267 {
3268   {
3269     USI opval = FLD (i_jmptarg);
3270     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3271     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3272   }
3273 }
3274
3275   SEM_BRANCH_FINI (vpc);
3276   return vpc;
3277 #undef FLD
3278 }
3279
3280 /* jal: jal $jmptarg */
3281
3282 static SEM_PC
3283 SEM_FN_NAME (iq2000bf,jal) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3284 {
3285 #define FLD(f) abuf->fields.sfmt_j.f
3286   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3287   int UNUSED written = 0;
3288   IADDR UNUSED pc = abuf->addr;
3289   SEM_BRANCH_INIT
3290   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3291
3292 {
3293 {
3294   {
3295     SI opval = ADDSI (pc, 8);
3296     SET_H_GR (((UINT) 31), opval);
3297     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3298   }
3299   {
3300     USI opval = FLD (i_jmptarg);
3301     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3302     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3303   }
3304 }
3305 }
3306
3307   SEM_BRANCH_FINI (vpc);
3308   return vpc;
3309 #undef FLD
3310 }
3311
3312 /* bmb: bmb $rs,$rt,$offset */
3313
3314 static SEM_PC
3315 SEM_FN_NAME (iq2000bf,bmb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
3316 {
3317 #define FLD(f) abuf->fields.sfmt_bbi.f
3318   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3319   int UNUSED written = 0;
3320   IADDR UNUSED pc = abuf->addr;
3321   SEM_BRANCH_INIT
3322   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3323
3324 {
3325   BI tmp_branch_;
3326   tmp_branch_ = 0;
3327 if (EQSI (ANDSI (GET_H_GR (FLD (f_rs)), 255), ANDSI (GET_H_GR (FLD (f_rt)), 255))) {
3328   tmp_branch_ = 1;
3329 }
3330 if (EQSI (ANDSI (GET_H_GR (FLD (f_rs)), 65280), ANDSI (GET_H_GR (FLD (f_rt)), 65280))) {
3331   tmp_branch_ = 1;
3332 }
3333 if (EQSI (ANDSI (GET_H_GR (FLD (f_rs)), 16711680), ANDSI (GET_H_GR (FLD (f_rt)), 16711680))) {
3334   tmp_branch_ = 1;
3335 }
3336 if (EQSI (ANDSI (GET_H_GR (FLD (f_rs)), 0xff000000), ANDSI (GET_H_GR (FLD (f_rt)), 0xff000000))) {
3337   tmp_branch_ = 1;
3338 }
3339 if (tmp_branch_) {
3340 {
3341   {
3342     USI opval = FLD (i_offset);
3343     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
3344     written |= (1 << 3);
3345     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3346   }
3347 }
3348 }
3349 }
3350
3351   abuf->written = written;
3352   SEM_BRANCH_FINI (vpc);
3353   return vpc;
3354 #undef FLD
3355 }
3356
3357 /* Table of all semantic fns.  */
3358
3359 static const struct sem_fn_desc sem_fns[] = {
3360   { IQ2000BF_INSN_X_INVALID, SEM_FN_NAME (iq2000bf,x_invalid) },
3361   { IQ2000BF_INSN_X_AFTER, SEM_FN_NAME (iq2000bf,x_after) },
3362   { IQ2000BF_INSN_X_BEFORE, SEM_FN_NAME (iq2000bf,x_before) },
3363   { IQ2000BF_INSN_X_CTI_CHAIN, SEM_FN_NAME (iq2000bf,x_cti_chain) },
3364   { IQ2000BF_INSN_X_CHAIN, SEM_FN_NAME (iq2000bf,x_chain) },
3365   { IQ2000BF_INSN_X_BEGIN, SEM_FN_NAME (iq2000bf,x_begin) },
3366   { IQ2000BF_INSN_ADD, SEM_FN_NAME (iq2000bf,add) },
3367   { IQ2000BF_INSN_ADDI, SEM_FN_NAME (iq2000bf,addi) },
3368   { IQ2000BF_INSN_ADDIU, SEM_FN_NAME (iq2000bf,addiu) },
3369   { IQ2000BF_INSN_ADDU, SEM_FN_NAME (iq2000bf,addu) },
3370   { IQ2000BF_INSN_ADO16, SEM_FN_NAME (iq2000bf,ado16) },
3371   { IQ2000BF_INSN_AND, SEM_FN_NAME (iq2000bf,and) },
3372   { IQ2000BF_INSN_ANDI, SEM_FN_NAME (iq2000bf,andi) },
3373   { IQ2000BF_INSN_ANDOI, SEM_FN_NAME (iq2000bf,andoi) },
3374   { IQ2000BF_INSN_NOR, SEM_FN_NAME (iq2000bf,nor) },
3375   { IQ2000BF_INSN_OR, SEM_FN_NAME (iq2000bf,or) },
3376   { IQ2000BF_INSN_ORI, SEM_FN_NAME (iq2000bf,ori) },
3377   { IQ2000BF_INSN_RAM, SEM_FN_NAME (iq2000bf,ram) },
3378   { IQ2000BF_INSN_SLL, SEM_FN_NAME (iq2000bf,sll) },
3379   { IQ2000BF_INSN_SLLV, SEM_FN_NAME (iq2000bf,sllv) },
3380   { IQ2000BF_INSN_SLMV, SEM_FN_NAME (iq2000bf,slmv) },
3381   { IQ2000BF_INSN_SLT, SEM_FN_NAME (iq2000bf,slt) },
3382   { IQ2000BF_INSN_SLTI, SEM_FN_NAME (iq2000bf,slti) },
3383   { IQ2000BF_INSN_SLTIU, SEM_FN_NAME (iq2000bf,sltiu) },
3384   { IQ2000BF_INSN_SLTU, SEM_FN_NAME (iq2000bf,sltu) },
3385   { IQ2000BF_INSN_SRA, SEM_FN_NAME (iq2000bf,sra) },
3386   { IQ2000BF_INSN_SRAV, SEM_FN_NAME (iq2000bf,srav) },
3387   { IQ2000BF_INSN_SRL, SEM_FN_NAME (iq2000bf,srl) },
3388   { IQ2000BF_INSN_SRLV, SEM_FN_NAME (iq2000bf,srlv) },
3389   { IQ2000BF_INSN_SRMV, SEM_FN_NAME (iq2000bf,srmv) },
3390   { IQ2000BF_INSN_SUB, SEM_FN_NAME (iq2000bf,sub) },
3391   { IQ2000BF_INSN_SUBU, SEM_FN_NAME (iq2000bf,subu) },
3392   { IQ2000BF_INSN_XOR, SEM_FN_NAME (iq2000bf,xor) },
3393   { IQ2000BF_INSN_XORI, SEM_FN_NAME (iq2000bf,xori) },
3394   { IQ2000BF_INSN_BBI, SEM_FN_NAME (iq2000bf,bbi) },
3395   { IQ2000BF_INSN_BBIN, SEM_FN_NAME (iq2000bf,bbin) },
3396   { IQ2000BF_INSN_BBV, SEM_FN_NAME (iq2000bf,bbv) },
3397   { IQ2000BF_INSN_BBVN, SEM_FN_NAME (iq2000bf,bbvn) },
3398   { IQ2000BF_INSN_BEQ, SEM_FN_NAME (iq2000bf,beq) },
3399   { IQ2000BF_INSN_BEQL, SEM_FN_NAME (iq2000bf,beql) },
3400   { IQ2000BF_INSN_BGEZ, SEM_FN_NAME (iq2000bf,bgez) },
3401   { IQ2000BF_INSN_BGEZAL, SEM_FN_NAME (iq2000bf,bgezal) },
3402   { IQ2000BF_INSN_BGEZALL, SEM_FN_NAME (iq2000bf,bgezall) },
3403   { IQ2000BF_INSN_BGEZL, SEM_FN_NAME (iq2000bf,bgezl) },
3404   { IQ2000BF_INSN_BLTZ, SEM_FN_NAME (iq2000bf,bltz) },
3405   { IQ2000BF_INSN_BLTZL, SEM_FN_NAME (iq2000bf,bltzl) },
3406   { IQ2000BF_INSN_BLTZAL, SEM_FN_NAME (iq2000bf,bltzal) },
3407   { IQ2000BF_INSN_BLTZALL, SEM_FN_NAME (iq2000bf,bltzall) },
3408   { IQ2000BF_INSN_BMB0, SEM_FN_NAME (iq2000bf,bmb0) },
3409   { IQ2000BF_INSN_BMB1, SEM_FN_NAME (iq2000bf,bmb1) },
3410   { IQ2000BF_INSN_BMB2, SEM_FN_NAME (iq2000bf,bmb2) },
3411   { IQ2000BF_INSN_BMB3, SEM_FN_NAME (iq2000bf,bmb3) },
3412   { IQ2000BF_INSN_BNE, SEM_FN_NAME (iq2000bf,bne) },
3413   { IQ2000BF_INSN_BNEL, SEM_FN_NAME (iq2000bf,bnel) },
3414   { IQ2000BF_INSN_JALR, SEM_FN_NAME (iq2000bf,jalr) },
3415   { IQ2000BF_INSN_JR, SEM_FN_NAME (iq2000bf,jr) },
3416   { IQ2000BF_INSN_LB, SEM_FN_NAME (iq2000bf,lb) },
3417   { IQ2000BF_INSN_LBU, SEM_FN_NAME (iq2000bf,lbu) },
3418   { IQ2000BF_INSN_LH, SEM_FN_NAME (iq2000bf,lh) },
3419   { IQ2000BF_INSN_LHU, SEM_FN_NAME (iq2000bf,lhu) },
3420   { IQ2000BF_INSN_LUI, SEM_FN_NAME (iq2000bf,lui) },
3421   { IQ2000BF_INSN_LW, SEM_FN_NAME (iq2000bf,lw) },
3422   { IQ2000BF_INSN_SB, SEM_FN_NAME (iq2000bf,sb) },
3423   { IQ2000BF_INSN_SH, SEM_FN_NAME (iq2000bf,sh) },
3424   { IQ2000BF_INSN_SW, SEM_FN_NAME (iq2000bf,sw) },
3425   { IQ2000BF_INSN_BREAK, SEM_FN_NAME (iq2000bf,break) },
3426   { IQ2000BF_INSN_SYSCALL, SEM_FN_NAME (iq2000bf,syscall) },
3427   { IQ2000BF_INSN_ANDOUI, SEM_FN_NAME (iq2000bf,andoui) },
3428   { IQ2000BF_INSN_ORUI, SEM_FN_NAME (iq2000bf,orui) },
3429   { IQ2000BF_INSN_BGTZ, SEM_FN_NAME (iq2000bf,bgtz) },
3430   { IQ2000BF_INSN_BGTZL, SEM_FN_NAME (iq2000bf,bgtzl) },
3431   { IQ2000BF_INSN_BLEZ, SEM_FN_NAME (iq2000bf,blez) },
3432   { IQ2000BF_INSN_BLEZL, SEM_FN_NAME (iq2000bf,blezl) },
3433   { IQ2000BF_INSN_MRGB, SEM_FN_NAME (iq2000bf,mrgb) },
3434   { IQ2000BF_INSN_BCTXT, SEM_FN_NAME (iq2000bf,bctxt) },
3435   { IQ2000BF_INSN_BC0F, SEM_FN_NAME (iq2000bf,bc0f) },
3436   { IQ2000BF_INSN_BC0FL, SEM_FN_NAME (iq2000bf,bc0fl) },
3437   { IQ2000BF_INSN_BC3F, SEM_FN_NAME (iq2000bf,bc3f) },
3438   { IQ2000BF_INSN_BC3FL, SEM_FN_NAME (iq2000bf,bc3fl) },
3439   { IQ2000BF_INSN_BC0T, SEM_FN_NAME (iq2000bf,bc0t) },
3440   { IQ2000BF_INSN_BC0TL, SEM_FN_NAME (iq2000bf,bc0tl) },
3441   { IQ2000BF_INSN_BC3T, SEM_FN_NAME (iq2000bf,bc3t) },
3442   { IQ2000BF_INSN_BC3TL, SEM_FN_NAME (iq2000bf,bc3tl) },
3443   { IQ2000BF_INSN_CFC0, SEM_FN_NAME (iq2000bf,cfc0) },
3444   { IQ2000BF_INSN_CFC1, SEM_FN_NAME (iq2000bf,cfc1) },
3445   { IQ2000BF_INSN_CFC2, SEM_FN_NAME (iq2000bf,cfc2) },
3446   { IQ2000BF_INSN_CFC3, SEM_FN_NAME (iq2000bf,cfc3) },
3447   { IQ2000BF_INSN_CHKHDR, SEM_FN_NAME (iq2000bf,chkhdr) },
3448   { IQ2000BF_INSN_CTC0, SEM_FN_NAME (iq2000bf,ctc0) },
3449   { IQ2000BF_INSN_CTC1, SEM_FN_NAME (iq2000bf,ctc1) },
3450   { IQ2000BF_INSN_CTC2, SEM_FN_NAME (iq2000bf,ctc2) },
3451   { IQ2000BF_INSN_CTC3, SEM_FN_NAME (iq2000bf,ctc3) },
3452   { IQ2000BF_INSN_JCR, SEM_FN_NAME (iq2000bf,jcr) },
3453   { IQ2000BF_INSN_LUC32, SEM_FN_NAME (iq2000bf,luc32) },
3454   { IQ2000BF_INSN_LUC32L, SEM_FN_NAME (iq2000bf,luc32l) },
3455   { IQ2000BF_INSN_LUC64, SEM_FN_NAME (iq2000bf,luc64) },
3456   { IQ2000BF_INSN_LUC64L, SEM_FN_NAME (iq2000bf,luc64l) },
3457   { IQ2000BF_INSN_LUK, SEM_FN_NAME (iq2000bf,luk) },
3458   { IQ2000BF_INSN_LULCK, SEM_FN_NAME (iq2000bf,lulck) },
3459   { IQ2000BF_INSN_LUM32, SEM_FN_NAME (iq2000bf,lum32) },
3460   { IQ2000BF_INSN_LUM32L, SEM_FN_NAME (iq2000bf,lum32l) },
3461   { IQ2000BF_INSN_LUM64, SEM_FN_NAME (iq2000bf,lum64) },
3462   { IQ2000BF_INSN_LUM64L, SEM_FN_NAME (iq2000bf,lum64l) },
3463   { IQ2000BF_INSN_LUR, SEM_FN_NAME (iq2000bf,lur) },
3464   { IQ2000BF_INSN_LURL, SEM_FN_NAME (iq2000bf,lurl) },
3465   { IQ2000BF_INSN_LUULCK, SEM_FN_NAME (iq2000bf,luulck) },
3466   { IQ2000BF_INSN_MFC0, SEM_FN_NAME (iq2000bf,mfc0) },
3467   { IQ2000BF_INSN_MFC1, SEM_FN_NAME (iq2000bf,mfc1) },
3468   { IQ2000BF_INSN_MFC2, SEM_FN_NAME (iq2000bf,mfc2) },
3469   { IQ2000BF_INSN_MFC3, SEM_FN_NAME (iq2000bf,mfc3) },
3470   { IQ2000BF_INSN_MTC0, SEM_FN_NAME (iq2000bf,mtc0) },
3471   { IQ2000BF_INSN_MTC1, SEM_FN_NAME (iq2000bf,mtc1) },
3472   { IQ2000BF_INSN_MTC2, SEM_FN_NAME (iq2000bf,mtc2) },
3473   { IQ2000BF_INSN_MTC3, SEM_FN_NAME (iq2000bf,mtc3) },
3474   { IQ2000BF_INSN_PKRL, SEM_FN_NAME (iq2000bf,pkrl) },
3475   { IQ2000BF_INSN_PKRLR1, SEM_FN_NAME (iq2000bf,pkrlr1) },
3476   { IQ2000BF_INSN_PKRLR30, SEM_FN_NAME (iq2000bf,pkrlr30) },
3477   { IQ2000BF_INSN_RB, SEM_FN_NAME (iq2000bf,rb) },
3478   { IQ2000BF_INSN_RBR1, SEM_FN_NAME (iq2000bf,rbr1) },
3479   { IQ2000BF_INSN_RBR30, SEM_FN_NAME (iq2000bf,rbr30) },
3480   { IQ2000BF_INSN_RFE, SEM_FN_NAME (iq2000bf,rfe) },
3481   { IQ2000BF_INSN_RX, SEM_FN_NAME (iq2000bf,rx) },
3482   { IQ2000BF_INSN_RXR1, SEM_FN_NAME (iq2000bf,rxr1) },
3483   { IQ2000BF_INSN_RXR30, SEM_FN_NAME (iq2000bf,rxr30) },
3484   { IQ2000BF_INSN_SLEEP, SEM_FN_NAME (iq2000bf,sleep) },
3485   { IQ2000BF_INSN_SRRD, SEM_FN_NAME (iq2000bf,srrd) },
3486   { IQ2000BF_INSN_SRRDL, SEM_FN_NAME (iq2000bf,srrdl) },
3487   { IQ2000BF_INSN_SRULCK, SEM_FN_NAME (iq2000bf,srulck) },
3488   { IQ2000BF_INSN_SRWR, SEM_FN_NAME (iq2000bf,srwr) },
3489   { IQ2000BF_INSN_SRWRU, SEM_FN_NAME (iq2000bf,srwru) },
3490   { IQ2000BF_INSN_TRAPQFL, SEM_FN_NAME (iq2000bf,trapqfl) },
3491   { IQ2000BF_INSN_TRAPQNE, SEM_FN_NAME (iq2000bf,trapqne) },
3492   { IQ2000BF_INSN_TRAPREL, SEM_FN_NAME (iq2000bf,traprel) },
3493   { IQ2000BF_INSN_WB, SEM_FN_NAME (iq2000bf,wb) },
3494   { IQ2000BF_INSN_WBU, SEM_FN_NAME (iq2000bf,wbu) },
3495   { IQ2000BF_INSN_WBR1, SEM_FN_NAME (iq2000bf,wbr1) },
3496   { IQ2000BF_INSN_WBR1U, SEM_FN_NAME (iq2000bf,wbr1u) },
3497   { IQ2000BF_INSN_WBR30, SEM_FN_NAME (iq2000bf,wbr30) },
3498   { IQ2000BF_INSN_WBR30U, SEM_FN_NAME (iq2000bf,wbr30u) },
3499   { IQ2000BF_INSN_WX, SEM_FN_NAME (iq2000bf,wx) },
3500   { IQ2000BF_INSN_WXU, SEM_FN_NAME (iq2000bf,wxu) },
3501   { IQ2000BF_INSN_WXR1, SEM_FN_NAME (iq2000bf,wxr1) },
3502   { IQ2000BF_INSN_WXR1U, SEM_FN_NAME (iq2000bf,wxr1u) },
3503   { IQ2000BF_INSN_WXR30, SEM_FN_NAME (iq2000bf,wxr30) },
3504   { IQ2000BF_INSN_WXR30U, SEM_FN_NAME (iq2000bf,wxr30u) },
3505   { IQ2000BF_INSN_LDW, SEM_FN_NAME (iq2000bf,ldw) },
3506   { IQ2000BF_INSN_SDW, SEM_FN_NAME (iq2000bf,sdw) },
3507   { IQ2000BF_INSN_J, SEM_FN_NAME (iq2000bf,j) },
3508   { IQ2000BF_INSN_JAL, SEM_FN_NAME (iq2000bf,jal) },
3509   { IQ2000BF_INSN_BMB, SEM_FN_NAME (iq2000bf,bmb) },
3510   { 0, 0 }
3511 };
3512
3513 /* Add the semantic fns to IDESC_TABLE.  */
3514
3515 void
3516 SEM_FN_NAME (iq2000bf,init_idesc_table) (SIM_CPU *current_cpu)
3517 {
3518   IDESC *idesc_table = CPU_IDESC (current_cpu);
3519   const struct sem_fn_desc *sf;
3520   int mach_num = MACH_NUM (CPU_MACH (current_cpu));
3521
3522   for (sf = &sem_fns[0]; sf->fn != 0; ++sf)
3523     {
3524       const CGEN_INSN *insn = idesc_table[sf->index].idata;
3525       int valid_p = (CGEN_INSN_VIRTUAL_P (insn)
3526                      || CGEN_INSN_MACH_HAS_P (insn, mach_num));
3527 #if FAST_P
3528       if (valid_p)
3529         idesc_table[sf->index].sem_fast = sf->fn;
3530       else
3531         idesc_table[sf->index].sem_fast = SEM_FN_NAME (iq2000bf,x_invalid);
3532 #else
3533       if (valid_p)
3534         idesc_table[sf->index].sem_full = sf->fn;
3535       else
3536         idesc_table[sf->index].sem_full = SEM_FN_NAME (iq2000bf,x_invalid);
3537 #endif
3538     }
3539 }
3540