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