target-sparc/op.c

   1 /*
   2    SPARC micro operations
   3
   4    Copyright (C) 2003 Thomas M. Ogrisegg <tom@fnord.at>
   5
   6    This library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2 of the License, or (at your option) any later version.
  10
  11    This library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with this library; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 */
  20
  21 #include "exec.h"
  22
  23  /*XXX*/
  24 #define REGNAME g0
  25 #define REG (env->gregs[0])
  26 #include "op_template.h"
  27 #define REGNAME g1
  28 #define REG (env->gregs[1])
  29 #include "op_template.h"
  30 #define REGNAME g2
  31 #define REG (env->gregs[2])
  32 #include "op_template.h"
  33 #define REGNAME g3
  34 #define REG (env->gregs[3])
  35 #include "op_template.h"
  36 #define REGNAME g4
  37 #define REG (env->gregs[4])
  38 #include "op_template.h"
  39 #define REGNAME g5
  40 #define REG (env->gregs[5])
  41 #include "op_template.h"
  42 #define REGNAME g6
  43 #define REG (env->gregs[6])
  44 #include "op_template.h"
  45 #define REGNAME g7
  46 #define REG (env->gregs[7])
  47 #include "op_template.h"
  48 #define REGNAME i0
  49 #define REG (env->regwptr[16])
  50 #include "op_template.h"
  51 #define REGNAME i1
  52 #define REG (env->regwptr[17])
  53 #include "op_template.h"
  54 #define REGNAME i2
  55 #define REG (env->regwptr[18])
  56 #include "op_template.h"
  57 #define REGNAME i3
  58 #define REG (env->regwptr[19])
  59 #include "op_template.h"
  60 #define REGNAME i4
  61 #define REG (env->regwptr[20])
  62 #include "op_template.h"
  63 #define REGNAME i5
  64 #define REG (env->regwptr[21])
  65 #include "op_template.h"
  66 #define REGNAME i6
  67 #define REG (env->regwptr[22])
  68 #include "op_template.h"
  69 #define REGNAME i7
  70 #define REG (env->regwptr[23])
  71 #include "op_template.h"
  72 #define REGNAME l0
  73 #define REG (env->regwptr[8])
  74 #include "op_template.h"
  75 #define REGNAME l1
  76 #define REG (env->regwptr[9])
  77 #include "op_template.h"
  78 #define REGNAME l2
  79 #define REG (env->regwptr[10])
  80 #include "op_template.h"
  81 #define REGNAME l3
  82 #define REG (env->regwptr[11])
  83 #include "op_template.h"
  84 #define REGNAME l4
  85 #define REG (env->regwptr[12])
  86 #include "op_template.h"
  87 #define REGNAME l5
  88 #define REG (env->regwptr[13])
  89 #include "op_template.h"
  90 #define REGNAME l6
  91 #define REG (env->regwptr[14])
  92 #include "op_template.h"
  93 #define REGNAME l7
  94 #define REG (env->regwptr[15])
  95 #include "op_template.h"
  96 #define REGNAME o0
  97 #define REG (env->regwptr[0])
  98 #include "op_template.h"
  99 #define REGNAME o1
 100 #define REG (env->regwptr[1])
 101 #include "op_template.h"
 102 #define REGNAME o2
 103 #define REG (env->regwptr[2])
 104 #include "op_template.h"
 105 #define REGNAME o3
 106 #define REG (env->regwptr[3])
 107 #include "op_template.h"
 108 #define REGNAME o4
 109 #define REG (env->regwptr[4])
 110 #include "op_template.h"
 111 #define REGNAME o5
 112 #define REG (env->regwptr[5])
 113 #include "op_template.h"
 114 #define REGNAME o6
 115 #define REG (env->regwptr[6])
 116 #include "op_template.h"
 117 #define REGNAME o7
 118 #define REG (env->regwptr[7])
 119 #include "op_template.h"
 120
 121 #define REGNAME f0
 122 #define REG (env->fpr[0])
 123 #include "fop_template.h"
 124 #define REGNAME f1
 125 #define REG (env->fpr[1])
 126 #include "fop_template.h"
 127 #define REGNAME f2
 128 #define REG (env->fpr[2])
 129 #include "fop_template.h"
 130 #define REGNAME f3
 131 #define REG (env->fpr[3])
 132 #include "fop_template.h"
 133 #define REGNAME f4
 134 #define REG (env->fpr[4])
 135 #include "fop_template.h"
 136 #define REGNAME f5
 137 #define REG (env->fpr[5])
 138 #include "fop_template.h"
 139 #define REGNAME f6
 140 #define REG (env->fpr[6])
 141 #include "fop_template.h"
 142 #define REGNAME f7
 143 #define REG (env->fpr[7])
 144 #include "fop_template.h"
 145 #define REGNAME f8
 146 #define REG (env->fpr[8])
 147 #include "fop_template.h"
 148 #define REGNAME f9
 149 #define REG (env->fpr[9])
 150 #include "fop_template.h"
 151 #define REGNAME f10
 152 #define REG (env->fpr[10])
 153 #include "fop_template.h"
 154 #define REGNAME f11
 155 #define REG (env->fpr[11])
 156 #include "fop_template.h"
 157 #define REGNAME f12
 158 #define REG (env->fpr[12])
 159 #include "fop_template.h"
 160 #define REGNAME f13
 161 #define REG (env->fpr[13])
 162 #include "fop_template.h"
 163 #define REGNAME f14
 164 #define REG (env->fpr[14])
 165 #include "fop_template.h"
 166 #define REGNAME f15
 167 #define REG (env->fpr[15])
 168 #include "fop_template.h"
 169 #define REGNAME f16
 170 #define REG (env->fpr[16])
 171 #include "fop_template.h"
 172 #define REGNAME f17
 173 #define REG (env->fpr[17])
 174 #include "fop_template.h"
 175 #define REGNAME f18
 176 #define REG (env->fpr[18])
 177 #include "fop_template.h"
 178 #define REGNAME f19
 179 #define REG (env->fpr[19])
 180 #include "fop_template.h"
 181 #define REGNAME f20
 182 #define REG (env->fpr[20])
 183 #include "fop_template.h"
 184 #define REGNAME f21
 185 #define REG (env->fpr[21])
 186 #include "fop_template.h"
 187 #define REGNAME f22
 188 #define REG (env->fpr[22])
 189 #include "fop_template.h"
 190 #define REGNAME f23
 191 #define REG (env->fpr[23])
 192 #include "fop_template.h"
 193 #define REGNAME f24
 194 #define REG (env->fpr[24])
 195 #include "fop_template.h"
 196 #define REGNAME f25
 197 #define REG (env->fpr[25])
 198 #include "fop_template.h"
 199 #define REGNAME f26
 200 #define REG (env->fpr[26])
 201 #include "fop_template.h"
 202 #define REGNAME f27
 203 #define REG (env->fpr[27])
 204 #include "fop_template.h"
 205 #define REGNAME f28
 206 #define REG (env->fpr[28])
 207 #include "fop_template.h"
 208 #define REGNAME f29
 209 #define REG (env->fpr[29])
 210 #include "fop_template.h"
 211 #define REGNAME f30
 212 #define REG (env->fpr[30])
 213 #include "fop_template.h"
 214 #define REGNAME f31
 215 #define REG (env->fpr[31])
 216 #include "fop_template.h"
 217
 218 #define EIP (env->pc)
 219
 220 #define FLAG_SET(x) ((env->psr&x)?1:0)
 221 #define FFLAG_SET(x) ((env->fsr&x)?1:0)
 222
 223 void OPPROTO op_movl_T0_0(void)
 224 {
 225     T0 = 0;
 226 }
 227
 228 void OPPROTO op_movl_T0_im(void)
 229 {
 230     T0 = PARAM1;
 231 }
 232
 233 void OPPROTO op_movl_T1_im(void)
 234 {
 235     T1 = PARAM1;
 236 }
 237
 238 void OPPROTO op_movl_T2_im(void)
 239 {
 240     T2 = PARAM1;
 241 }
 242
 243 void OPPROTO op_add_T1_T0(void)
 244 {
 245     T0 += T1;
 246 }
 247
 248 void OPPROTO op_add_T1_T0_cc(void)
 249 {
 250     target_ulong src1;
 251
 252     src1 = T0;
 253     T0 += T1;
 254     env->psr = 0;
 255     if (!T0)
 256         env->psr |= PSR_ZERO;
 257     if ((int32_t) T0 < 0)
 258         env->psr |= PSR_NEG;
 259     if (T0 < src1)
 260         env->psr |= PSR_CARRY;
 261     if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1 << 31))
 262         env->psr |= PSR_OVF;
 263     /* V9 xcc */
 264     FORCE_RET();
 265 }
 266
 267 void OPPROTO op_addx_T1_T0(void)
 268 {
 269     T0 += T1 + FLAG_SET(PSR_CARRY);
 270 }
 271
 272 void OPPROTO op_addx_T1_T0_cc(void)
 273 {
 274     target_ulong src1;
 275
 276     src1 = T0;
 277     T0 += T1 + FLAG_SET(PSR_CARRY);
 278     env->psr = 0;
 279     if (!T0)
 280         env->psr |= PSR_ZERO;
 281     if ((int32_t) T0 < 0)
 282         env->psr |= PSR_NEG;
 283     if (T0 < src1)
 284         env->psr |= PSR_CARRY;
 285     if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1 << 31))
 286         env->psr |= PSR_OVF;
 287     /* V9 xcc */
 288     FORCE_RET();
 289 }
 290
 291 void OPPROTO op_sub_T1_T0(void)
 292 {
 293     T0 -= T1;
 294 }
 295
 296 void OPPROTO op_sub_T1_T0_cc(void)
 297 {
 298     target_ulong src1;
 299
 300     src1 = T0;
 301     T0 -= T1;
 302     env->psr = 0;
 303     if (!T0)
 304         env->psr |= PSR_ZERO;
 305     if ((int32_t) T0 < 0)
 306         env->psr |= PSR_NEG;
 307     if (src1 < T1)
 308         env->psr |= PSR_CARRY;
 309     if (((src1 ^ T1) & (src1 ^ T0)) & (1 << 31))
 310         env->psr |= PSR_OVF;
 311     /* V9 xcc */
 312     FORCE_RET();
 313 }
 314
 315 void OPPROTO op_subx_T1_T0(void)
 316 {
 317     T0 -= T1 + FLAG_SET(PSR_CARRY);
 318 }
 319
 320 void OPPROTO op_subx_T1_T0_cc(void)
 321 {
 322     target_ulong src1;
 323
 324     src1 = T0;
 325     T0 -= T1 + FLAG_SET(PSR_CARRY);
 326     env->psr = 0;
 327     if (!T0)
 328         env->psr |= PSR_ZERO;
 329     if ((int32_t) T0 < 0)
 330         env->psr |= PSR_NEG;
 331     if (src1 < T1)
 332         env->psr |= PSR_CARRY;
 333     if (((src1 ^ T1) & (src1 ^ T0)) & (1 << 31))
 334         env->psr |= PSR_OVF;
 335     /* V9 xcc */
 336     FORCE_RET();
 337 }
 338
 339 void OPPROTO op_and_T1_T0(void)
 340 {
 341     T0 &= T1;
 342 }
 343
 344 void OPPROTO op_or_T1_T0(void)
 345 {
 346     T0 |= T1;
 347 }
 348
 349 void OPPROTO op_xor_T1_T0(void)
 350 {
 351     T0 ^= T1;
 352 }
 353
 354 void OPPROTO op_andn_T1_T0(void)
 355 {
 356     T0 &= ~T1;
 357 }
 358
 359 void OPPROTO op_orn_T1_T0(void)
 360 {
 361     T0 |= ~T1;
 362 }
 363
 364 void OPPROTO op_xnor_T1_T0(void)
 365 {
 366     T0 ^= ~T1;
 367 }
 368
 369 void OPPROTO op_umul_T1_T0(void)
 370 {
 371     uint64_t res;
 372     res = (uint64_t) T0 * (uint64_t) T1;
 373     T0 = res & 0xffffffff;
 374     env->y = res >> 32;
 375 }
 376
 377 void OPPROTO op_smul_T1_T0(void)
 378 {
 379     uint64_t res;
 380     res = (int64_t) ((int32_t) T0) * (int64_t) ((int32_t) T1);
 381     T0 = res & 0xffffffff;
 382     env->y = res >> 32;
 383 }
 384
 385 void OPPROTO op_mulscc_T1_T0(void)
 386 {
 387     unsigned int b1, N, V, b2;
 388     target_ulong src1;
 389
 390     N = FLAG_SET(PSR_NEG);
 391     V = FLAG_SET(PSR_OVF);
 392     b1 = N ^ V;
 393     b2 = T0 & 1;
 394     T0 = (b1 << 31) | (T0 >> 1);
 395     if (!(env->y & 1))
 396         T1 = 0;
 397     /* do addition and update flags */
 398     src1 = T0;
 399     T0 += T1;
 400     env->psr = 0;
 401     if (!T0)
 402         env->psr |= PSR_ZERO;
 403     if ((int32_t) T0 < 0)
 404         env->psr |= PSR_NEG;
 405     if (T0 < src1)
 406         env->psr |= PSR_CARRY;
 407     if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1 << 31))
 408         env->psr |= PSR_OVF;
 409     env->y = (b2 << 31) | (env->y >> 1);
 410     FORCE_RET();
 411 }
 412
 413 void OPPROTO op_udiv_T1_T0(void)
 414 {
 415     uint64_t x0;
 416     uint32_t x1;
 417
 418     x0 = T0 | ((uint64_t) (env->y) << 32);
 419     x1 = T1;
 420     x0 = x0 / x1;
 421     if (x0 > 0xffffffff) {
 422         T0 = 0xffffffff;
 423         T1 = 1;
 424     } else {
 425         T0 = x0;
 426         T1 = 0;
 427     }
 428     FORCE_RET();
 429 }
 430
 431 void OPPROTO op_sdiv_T1_T0(void)
 432 {
 433     int64_t x0;
 434     int32_t x1;
 435
 436     x0 = T0 | ((int64_t) (env->y) << 32);
 437     x1 = T1;
 438     x0 = x0 / x1;
 439     if ((int32_t) x0 != x0) {
 440         T0 = x0 < 0? 0x80000000: 0x7fffffff;
 441         T1 = 1;
 442     } else {
 443         T0 = x0;
 444         T1 = 0;
 445     }
 446     FORCE_RET();
 447 }
 448
 449 void OPPROTO op_div_cc(void)
 450 {
 451     env->psr = 0;
 452     if (!T0)
 453         env->psr |= PSR_ZERO;
 454     if ((int32_t) T0 < 0)
 455         env->psr |= PSR_NEG;
 456     if (T1)
 457         env->psr |= PSR_OVF;
 458     /* V9 xcc */
 459     FORCE_RET();
 460 }
 461
 462 void OPPROTO op_logic_T0_cc(void)
 463 {
 464     env->psr = 0;
 465     if (!T0)
 466         env->psr |= PSR_ZERO;
 467     if ((int32_t) T0 < 0)
 468         env->psr |= PSR_NEG;
 469     /* V9 xcc */
 470     FORCE_RET();
 471 }
 472
 473 void OPPROTO op_sll(void)
 474 {
 475     T0 <<= T1;
 476 }
 477
 478 void OPPROTO op_srl(void)
 479 {
 480     T0 >>= T1;
 481 }
 482
 483 void OPPROTO op_sra(void)
 484 {
 485     T0 = ((int32_t) T0) >> T1;
 486 }
 487
 488 /* Load and store */
 489 #define MEMSUFFIX _raw
 490 #include "op_mem.h"
 491 #if !defined(CONFIG_USER_ONLY)
 492 #define MEMSUFFIX _user
 493 #include "op_mem.h"
 494
 495 #define MEMSUFFIX _kernel
 496 #include "op_mem.h"
 497 #endif
 498
 499 void OPPROTO op_ldfsr(void)
 500 {
 501     env->fsr = *((uint32_t *) &FT0);
 502     helper_ldfsr();
 503 }
 504
 505 void OPPROTO op_stfsr(void)
 506 {
 507     *((uint32_t *) &FT0) = env->fsr;
 508 }
 509
 510 void OPPROTO op_wry(void)
 511 {
 512     env->y = T0;
 513 }
 514
 515 void OPPROTO op_rdy(void)
 516 {
 517     T0 = env->y;
 518 }
 519
 520 void OPPROTO op_rdwim(void)
 521 {
 522     T0 = env->wim;
 523 }
 524
 525 void OPPROTO op_wrwim(void)
 526 {
 527     env->wim = T0;
 528     FORCE_RET();
 529 }
 530
 531 void OPPROTO op_rdpsr(void)
 532 {
 533     do_rdpsr();
 534 }
 535
 536 void OPPROTO op_wrpsr(void)
 537 {
 538     do_wrpsr();
 539     FORCE_RET();
 540 }
 541
 542 void OPPROTO op_rdtbr(void)
 543 {
 544     T0 = env->tbr;
 545 }
 546
 547 void OPPROTO op_wrtbr(void)
 548 {
 549     env->tbr = T0;
 550     FORCE_RET();
 551 }
 552
 553 void OPPROTO op_rett(void)
 554 {
 555     helper_rett();
 556     FORCE_RET();
 557 }
 558
 559 void raise_exception(int tt)
 560 {
 561     env->exception_index = tt;
 562     cpu_loop_exit();
 563 }
 564
 565 /* XXX: use another pointer for %iN registers to avoid slow wrapping
 566    handling ? */
 567 void OPPROTO op_save(void)
 568 {
 569     uint32_t cwp;
 570     cwp = (env->cwp - 1) & (NWINDOWS - 1);
 571     if (env->wim & (1 << cwp)) {
 572         raise_exception(TT_WIN_OVF);
 573     }
 574     set_cwp(cwp);
 575     FORCE_RET();
 576 }
 577
 578 void OPPROTO op_restore(void)
 579 {
 580     uint32_t cwp;
 581     cwp = (env->cwp + 1) & (NWINDOWS - 1);
 582     if (env->wim & (1 << cwp)) {
 583         raise_exception(TT_WIN_UNF);
 584     }
 585     set_cwp(cwp);
 586     FORCE_RET();
 587 }
 588
 589 void OPPROTO op_exception(void)
 590 {
 591     env->exception_index = PARAM1;
 592     cpu_loop_exit();
 593 }
 594
 595 void OPPROTO op_trap_T0(void)
 596 {
 597     env->exception_index = TT_TRAP + (T0 & 0x7f);
 598     cpu_loop_exit();
 599 }
 600
 601 void OPPROTO op_trapcc_T0(void)
 602 {
 603     if (T2) {
 604         env->exception_index = TT_TRAP + (T0 & 0x7f);
 605         cpu_loop_exit();
 606     }
 607     FORCE_RET();
 608 }
 609
 610 void OPPROTO op_trap_ifnofpu(void)
 611 {
 612     if (!env->psref) {
 613         env->exception_index = TT_NFPU_INSN;
 614         cpu_loop_exit();
 615     }
 616     FORCE_RET();
 617 }
 618
 619 void OPPROTO op_fpexception_im(void)
 620 {
 621     env->exception_index = TT_FP_EXCP;
 622     env->fsr &= ~FSR_FTT_MASK;
 623     env->fsr |= PARAM1;
 624     cpu_loop_exit();
 625     FORCE_RET();
 626 }
 627
 628 void OPPROTO op_debug(void)
 629 {
 630     helper_debug();
 631 }
 632
 633 void OPPROTO op_exit_tb(void)
 634 {
 635     EXIT_TB();
 636 }
 637
 638 void OPPROTO op_eval_be(void)
 639 {
 640     T2 = FLAG_SET(PSR_ZERO);
 641 }
 642
 643 void OPPROTO op_eval_ble(void)
 644 {
 645     target_ulong Z = FLAG_SET(PSR_ZERO), N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF);
 646
 647     T2 = Z | (N ^ V);
 648 }
 649
 650 void OPPROTO op_eval_bl(void)
 651 {
 652     target_ulong N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF);
 653
 654     T2 = N ^ V;
 655 }
 656
 657 void OPPROTO op_eval_bleu(void)
 658 {
 659     target_ulong Z = FLAG_SET(PSR_ZERO), C = FLAG_SET(PSR_CARRY);
 660
 661     T2 = C | Z;
 662 }
 663
 664 void OPPROTO op_eval_bcs(void)
 665 {
 666     T2 = FLAG_SET(PSR_CARRY);
 667 }
 668
 669 void OPPROTO op_eval_bvs(void)
 670 {
 671     T2 = FLAG_SET(PSR_OVF);
 672 }
 673
 674 void OPPROTO op_eval_bneg(void)
 675 {
 676     T2 = FLAG_SET(PSR_NEG);
 677 }
 678
 679 void OPPROTO op_eval_bne(void)
 680 {
 681     T2 = !FLAG_SET(PSR_ZERO);
 682 }
 683
 684 void OPPROTO op_eval_bg(void)
 685 {
 686     target_ulong Z = FLAG_SET(PSR_ZERO), N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF);
 687
 688     T2 = !(Z | (N ^ V));
 689 }
 690
 691 void OPPROTO op_eval_bge(void)
 692 {
 693     target_ulong N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF);
 694
 695     T2 = !(N ^ V);
 696 }
 697
 698 void OPPROTO op_eval_bgu(void)
 699 {
 700     target_ulong Z = FLAG_SET(PSR_ZERO), C = FLAG_SET(PSR_CARRY);
 701
 702     T2 = !(C | Z);
 703 }
 704
 705 void OPPROTO op_eval_bcc(void)
 706 {
 707     T2 = !FLAG_SET(PSR_CARRY);
 708 }
 709
 710 void OPPROTO op_eval_bpos(void)
 711 {
 712     T2 = !FLAG_SET(PSR_NEG);
 713 }
 714
 715 void OPPROTO op_eval_bvc(void)
 716 {
 717     T2 = !FLAG_SET(PSR_OVF);
 718 }
 719
 720 /* FCC1:FCC0: 0 =, 1 <, 2 >, 3 u */
 721
 722 void OPPROTO op_eval_fbne(void)
 723 {
 724 // !0
 725     T2 = (env->fsr & (FSR_FCC1 | FSR_FCC0)); /* L or G or U */
 726 }
 727
 728 void OPPROTO op_eval_fblg(void)
 729 {
 730 // 1 or 2
 731     T2 = FFLAG_SET(FSR_FCC0) ^ FFLAG_SET(FSR_FCC1);
 732 }
 733
 734 void OPPROTO op_eval_fbul(void)
 735 {
 736 // 1 or 3
 737     T2 = FFLAG_SET(FSR_FCC0);
 738 }
 739
 740 void OPPROTO op_eval_fbl(void)
 741 {
 742 // 1
 743     T2 = FFLAG_SET(FSR_FCC0) & !FFLAG_SET(FSR_FCC1);
 744 }
 745
 746 void OPPROTO op_eval_fbug(void)
 747 {
 748 // 2 or 3
 749     T2 = FFLAG_SET(FSR_FCC1);
 750 }
 751
 752 void OPPROTO op_eval_fbg(void)
 753 {
 754 // 2
 755     T2 = !FFLAG_SET(FSR_FCC0) & FFLAG_SET(FSR_FCC1);
 756 }
 757
 758 void OPPROTO op_eval_fbu(void)
 759 {
 760 // 3
 761     T2 = FFLAG_SET(FSR_FCC0) & FFLAG_SET(FSR_FCC1);
 762 }
 763
 764 void OPPROTO op_eval_fbe(void)
 765 {
 766 // 0
 767     T2 = !FFLAG_SET(FSR_FCC0) & !FFLAG_SET(FSR_FCC1);
 768 }
 769
 770 void OPPROTO op_eval_fbue(void)
 771 {
 772 // 0 or 3
 773     T2 = !(FFLAG_SET(FSR_FCC1) ^ FFLAG_SET(FSR_FCC0));
 774 }
 775
 776 void OPPROTO op_eval_fbge(void)
 777 {
 778 // 0 or 2
 779     T2 = !FFLAG_SET(FSR_FCC0);
 780 }
 781
 782 void OPPROTO op_eval_fbuge(void)
 783 {
 784 // !1
 785     T2 = !(FFLAG_SET(FSR_FCC0) & !FFLAG_SET(FSR_FCC1));
 786 }
 787
 788 void OPPROTO op_eval_fble(void)
 789 {
 790 // 0 or 1
 791     T2 = !FFLAG_SET(FSR_FCC1);
 792 }
 793
 794 void OPPROTO op_eval_fbule(void)
 795 {
 796 // !2
 797     T2 = !(!FFLAG_SET(FSR_FCC0) & FFLAG_SET(FSR_FCC1));
 798 }
 799
 800 void OPPROTO op_eval_fbo(void)
 801 {
 802 // !3
 803     T2 = !(FFLAG_SET(FSR_FCC0) & FFLAG_SET(FSR_FCC1));
 804 }
 805
 806 void OPPROTO op_jmp_im(void)
 807 {
 808     env->pc = PARAM1;
 809 }
 810
 811 void OPPROTO op_movl_npc_im(void)
 812 {
 813     env->npc = PARAM1;
 814 }
 815
 816 void OPPROTO op_movl_npc_T0(void)
 817 {
 818     env->npc = T0;
 819 }
 820
 821 void OPPROTO op_next_insn(void)
 822 {
 823     env->pc = env->npc;
 824     env->npc = env->npc + 4;
 825 }
 826
 827 void OPPROTO op_branch(void)
 828 {
 829     env->npc = PARAM3; /* XXX: optimize */
 830     JUMP_TB(op_branch, PARAM1, 0, PARAM2);
 831 }
 832
 833 void OPPROTO op_branch2(void)
 834 {
 835     if (T2) {
 836         env->npc = PARAM2 + 4;
 837         JUMP_TB(op_branch2, PARAM1, 0, PARAM2);
 838     } else {
 839         env->npc = PARAM3 + 4;
 840         JUMP_TB(op_branch2, PARAM1, 1, PARAM3);
 841     }
 842     FORCE_RET();
 843 }
 844
 845 void OPPROTO op_branch_a(void)
 846 {
 847     if (T2) {
 848         env->npc = PARAM2; /* XXX: optimize */
 849         JUMP_TB(op_branch_a, PARAM1, 0, PARAM3);
 850     } else {
 851         env->npc = PARAM3 + 8; /* XXX: optimize */
 852         JUMP_TB(op_branch_a, PARAM1, 1, PARAM3 + 4);
 853     }
 854     FORCE_RET();
 855 }
 856
 857 void OPPROTO op_generic_branch(void)
 858 {
 859     if (T2) {
 860         env->npc = PARAM1;
 861     } else {
 862         env->npc = PARAM2;
 863     }
 864     FORCE_RET();
 865 }
 866
 867 void OPPROTO op_flush_T0(void)
 868 {
 869     helper_flush(T0);
 870 }
 871
 872 void OPPROTO op_fnegs(void)
 873 {
 874     FT0 = -FT1;
 875 }
 876
 877 void OPPROTO op_fabss(void)
 878 {
 879     do_fabss();
 880 }
 881
 882 void OPPROTO op_fsqrts(void)
 883 {
 884     do_fsqrts();
 885 }
 886
 887 void OPPROTO op_fsqrtd(void)
 888 {
 889     do_fsqrtd();
 890 }
 891
 892 void OPPROTO op_fmuls(void)
 893 {
 894     FT0 *= FT1;
 895 }
 896
 897 void OPPROTO op_fmuld(void)
 898 {
 899     DT0 *= DT1;
 900 }
 901
 902 void OPPROTO op_fsmuld(void)
 903 {
 904     DT0 = FT0 * FT1;
 905 }
 906
 907 void OPPROTO op_fadds(void)
 908 {
 909     FT0 += FT1;
 910 }
 911
 912 void OPPROTO op_faddd(void)
 913 {
 914     DT0 += DT1;
 915 }
 916
 917 void OPPROTO op_fsubs(void)
 918 {
 919     FT0 -= FT1;
 920 }
 921
 922 void OPPROTO op_fsubd(void)
 923 {
 924     DT0 -= DT1;
 925 }
 926
 927 void OPPROTO op_fdivs(void)
 928 {
 929     FT0 /= FT1;
 930 }
 931
 932 void OPPROTO op_fdivd(void)
 933 {
 934     DT0 /= DT1;
 935 }
 936
 937 void OPPROTO op_fcmps(void)
 938 {
 939     do_fcmps();
 940 }
 941
 942 void OPPROTO op_fcmpd(void)
 943 {
 944     do_fcmpd();
 945 }
 946
 947 #ifdef USE_INT_TO_FLOAT_HELPERS
 948 void OPPROTO op_fitos(void)
 949 {
 950     do_fitos();
 951 }
 952
 953 void OPPROTO op_fitod(void)
 954 {
 955     do_fitod();
 956 }
 957 #else
 958 void OPPROTO op_fitos(void)
 959 {
 960     FT0 = (float) *((int32_t *)&FT1);
 961 }
 962
 963 void OPPROTO op_fitod(void)
 964 {
 965     DT0 = (double) *((int32_t *)&FT1);
 966 }
 967 #endif
 968
 969 void OPPROTO op_fdtos(void)
 970 {
 971     FT0 = (float) DT1;
 972 }
 973
 974 void OPPROTO op_fstod(void)
 975 {
 976     DT0 = (double) FT1;
 977 }
 978
 979 void OPPROTO op_fstoi(void)
 980 {
 981     *((int32_t *)&FT0) = (int32_t) FT1;
 982 }
 983
 984 void OPPROTO op_fdtoi(void)
 985 {
 986     *((int32_t *)&FT0) = (int32_t) DT1;
 987 }
 988
 989 void OPPROTO op_ld_asi()
 990 {
 991     helper_ld_asi(PARAM1, PARAM2, PARAM3);
 992 }
 993
 994 void OPPROTO op_st_asi()
 995 {
 996     helper_st_asi(PARAM1, PARAM2, PARAM3);
 997 }
 998