sim/iq2000/sem.c

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