![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to op.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / target-sparc|
Return to op.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / target-sparc |
1.1 ! root 1: /* ! 2: SPARC micro operations ! 3: ! 4: Copyright (C) 2003 Thomas M. Ogrisegg <[email protected]> ! 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 (REGWPTR[16]) ! 50: #include "op_template.h" ! 51: #define REGNAME i1 ! 52: #define REG (REGWPTR[17]) ! 53: #include "op_template.h" ! 54: #define REGNAME i2 ! 55: #define REG (REGWPTR[18]) ! 56: #include "op_template.h" ! 57: #define REGNAME i3 ! 58: #define REG (REGWPTR[19]) ! 59: #include "op_template.h" ! 60: #define REGNAME i4 ! 61: #define REG (REGWPTR[20]) ! 62: #include "op_template.h" ! 63: #define REGNAME i5 ! 64: #define REG (REGWPTR[21]) ! 65: #include "op_template.h" ! 66: #define REGNAME i6 ! 67: #define REG (REGWPTR[22]) ! 68: #include "op_template.h" ! 69: #define REGNAME i7 ! 70: #define REG (REGWPTR[23]) ! 71: #include "op_template.h" ! 72: #define REGNAME l0 ! 73: #define REG (REGWPTR[8]) ! 74: #include "op_template.h" ! 75: #define REGNAME l1 ! 76: #define REG (REGWPTR[9]) ! 77: #include "op_template.h" ! 78: #define REGNAME l2 ! 79: #define REG (REGWPTR[10]) ! 80: #include "op_template.h" ! 81: #define REGNAME l3 ! 82: #define REG (REGWPTR[11]) ! 83: #include "op_template.h" ! 84: #define REGNAME l4 ! 85: #define REG (REGWPTR[12]) ! 86: #include "op_template.h" ! 87: #define REGNAME l5 ! 88: #define REG (REGWPTR[13]) ! 89: #include "op_template.h" ! 90: #define REGNAME l6 ! 91: #define REG (REGWPTR[14]) ! 92: #include "op_template.h" ! 93: #define REGNAME l7 ! 94: #define REG (REGWPTR[15]) ! 95: #include "op_template.h" ! 96: #define REGNAME o0 ! 97: #define REG (REGWPTR[0]) ! 98: #include "op_template.h" ! 99: #define REGNAME o1 ! 100: #define REG (REGWPTR[1]) ! 101: #include "op_template.h" ! 102: #define REGNAME o2 ! 103: #define REG (REGWPTR[2]) ! 104: #include "op_template.h" ! 105: #define REGNAME o3 ! 106: #define REG (REGWPTR[3]) ! 107: #include "op_template.h" ! 108: #define REGNAME o4 ! 109: #define REG (REGWPTR[4]) ! 110: #include "op_template.h" ! 111: #define REGNAME o5 ! 112: #define REG (REGWPTR[5]) ! 113: #include "op_template.h" ! 114: #define REGNAME o6 ! 115: #define REG (REGWPTR[6]) ! 116: #include "op_template.h" ! 117: #define REGNAME o7 ! 118: #define REG (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: #ifdef TARGET_SPARC64 ! 219: #define REGNAME f32 ! 220: #define REG (env->fpr[32]) ! 221: #include "fop_template.h" ! 222: #define REGNAME f34 ! 223: #define REG (env->fpr[34]) ! 224: #include "fop_template.h" ! 225: #define REGNAME f36 ! 226: #define REG (env->fpr[36]) ! 227: #include "fop_template.h" ! 228: #define REGNAME f38 ! 229: #define REG (env->fpr[38]) ! 230: #include "fop_template.h" ! 231: #define REGNAME f40 ! 232: #define REG (env->fpr[40]) ! 233: #include "fop_template.h" ! 234: #define REGNAME f42 ! 235: #define REG (env->fpr[42]) ! 236: #include "fop_template.h" ! 237: #define REGNAME f44 ! 238: #define REG (env->fpr[44]) ! 239: #include "fop_template.h" ! 240: #define REGNAME f46 ! 241: #define REG (env->fpr[46]) ! 242: #include "fop_template.h" ! 243: #define REGNAME f48 ! 244: #define REG (env->fpr[47]) ! 245: #include "fop_template.h" ! 246: #define REGNAME f50 ! 247: #define REG (env->fpr[50]) ! 248: #include "fop_template.h" ! 249: #define REGNAME f52 ! 250: #define REG (env->fpr[52]) ! 251: #include "fop_template.h" ! 252: #define REGNAME f54 ! 253: #define REG (env->fpr[54]) ! 254: #include "fop_template.h" ! 255: #define REGNAME f56 ! 256: #define REG (env->fpr[56]) ! 257: #include "fop_template.h" ! 258: #define REGNAME f58 ! 259: #define REG (env->fpr[58]) ! 260: #include "fop_template.h" ! 261: #define REGNAME f60 ! 262: #define REG (env->fpr[60]) ! 263: #include "fop_template.h" ! 264: #define REGNAME f62 ! 265: #define REG (env->fpr[62]) ! 266: #include "fop_template.h" ! 267: #endif ! 268: ! 269: #ifdef TARGET_SPARC64 ! 270: #ifdef WORDS_BIGENDIAN ! 271: typedef union UREG64 { ! 272: struct { uint16_t v3, v2, v1, v0; } w; ! 273: struct { uint32_t v1, v0; } l; ! 274: uint64_t q; ! 275: } UREG64; ! 276: #else ! 277: typedef union UREG64 { ! 278: struct { uint16_t v0, v1, v2, v3; } w; ! 279: struct { uint32_t v0, v1; } l; ! 280: uint64_t q; ! 281: } UREG64; ! 282: #endif ! 283: ! 284: #define PARAMQ1 \ ! 285: ({\ ! 286: UREG64 __p;\ ! 287: __p.l.v1 = PARAM1;\ ! 288: __p.l.v0 = PARAM2;\ ! 289: __p.q;\ ! 290: }) ! 291: ! 292: void OPPROTO op_movq_T0_im64(void) ! 293: { ! 294: T0 = PARAMQ1; ! 295: } ! 296: ! 297: void OPPROTO op_movq_T1_im64(void) ! 298: { ! 299: T1 = PARAMQ1; ! 300: } ! 301: ! 302: #define XFLAG_SET(x) ((env->xcc&x)?1:0) ! 303: ! 304: #else ! 305: #define EIP (env->pc) ! 306: #endif ! 307: ! 308: #define FLAG_SET(x) ((env->psr&x)?1:0) ! 309: ! 310: void OPPROTO op_movl_T0_0(void) ! 311: { ! 312: T0 = 0; ! 313: } ! 314: ! 315: void OPPROTO op_movl_T0_im(void) ! 316: { ! 317: T0 = (uint32_t)PARAM1; ! 318: } ! 319: ! 320: void OPPROTO op_movl_T1_im(void) ! 321: { ! 322: T1 = (uint32_t)PARAM1; ! 323: } ! 324: ! 325: void OPPROTO op_movl_T2_im(void) ! 326: { ! 327: T2 = (uint32_t)PARAM1; ! 328: } ! 329: ! 330: void OPPROTO op_movl_T0_sim(void) ! 331: { ! 332: T0 = (int32_t)PARAM1; ! 333: } ! 334: ! 335: void OPPROTO op_movl_T1_sim(void) ! 336: { ! 337: T1 = (int32_t)PARAM1; ! 338: } ! 339: ! 340: void OPPROTO op_movl_T2_sim(void) ! 341: { ! 342: T2 = (int32_t)PARAM1; ! 343: } ! 344: ! 345: void OPPROTO op_movl_T0_env(void) ! 346: { ! 347: T0 = *(uint32_t *)((char *)env + PARAM1); ! 348: } ! 349: ! 350: void OPPROTO op_movl_env_T0(void) ! 351: { ! 352: *(uint32_t *)((char *)env + PARAM1) = T0; ! 353: } ! 354: ! 355: void OPPROTO op_movtl_T0_env(void) ! 356: { ! 357: T0 = *(target_ulong *)((char *)env + PARAM1); ! 358: } ! 359: ! 360: void OPPROTO op_movtl_env_T0(void) ! 361: { ! 362: *(target_ulong *)((char *)env + PARAM1) = T0; ! 363: } ! 364: ! 365: void OPPROTO op_add_T1_T0(void) ! 366: { ! 367: T0 += T1; ! 368: } ! 369: ! 370: void OPPROTO op_add_T1_T0_cc(void) ! 371: { ! 372: target_ulong src1; ! 373: ! 374: src1 = T0; ! 375: T0 += T1; ! 376: env->psr = 0; ! 377: #ifdef TARGET_SPARC64 ! 378: if (!(T0 & 0xffffffff)) ! 379: env->psr |= PSR_ZERO; ! 380: if ((int32_t) T0 < 0) ! 381: env->psr |= PSR_NEG; ! 382: if ((src1 & 0xffffffff) < (T1 & 0xffffffff)) ! 383: env->psr |= PSR_CARRY; ! 384: if ((((src1 & 0xffffffff) ^ (T1 & 0xffffffff) ^ -1) & ! 385: ((src1 & 0xffffffff) ^ (T0 & 0xffffffff))) & (1 << 31)) ! 386: env->psr |= PSR_OVF; ! 387: ! 388: env->xcc = 0; ! 389: if (!T0) ! 390: env->xcc |= PSR_ZERO; ! 391: if ((int64_t) T0 < 0) ! 392: env->xcc |= PSR_NEG; ! 393: if (T0 < src1) ! 394: env->xcc |= PSR_CARRY; ! 395: if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1ULL << 63)) ! 396: env->xcc |= PSR_OVF; ! 397: #else ! 398: if (!T0) ! 399: env->psr |= PSR_ZERO; ! 400: if ((int32_t) T0 < 0) ! 401: env->psr |= PSR_NEG; ! 402: if (T0 < src1) ! 403: env->psr |= PSR_CARRY; ! 404: if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1 << 31)) ! 405: env->psr |= PSR_OVF; ! 406: #endif ! 407: FORCE_RET(); ! 408: } ! 409: ! 410: void OPPROTO op_addx_T1_T0(void) ! 411: { ! 412: T0 += T1 + FLAG_SET(PSR_CARRY); ! 413: } ! 414: ! 415: void OPPROTO op_addx_T1_T0_cc(void) ! 416: { ! 417: target_ulong src1; ! 418: ! 419: src1 = T0; ! 420: T0 += T1 + FLAG_SET(PSR_CARRY); ! 421: env->psr = 0; ! 422: #ifdef TARGET_SPARC64 ! 423: if (!(T0 & 0xffffffff)) ! 424: env->psr |= PSR_ZERO; ! 425: if ((int32_t) T0 < 0) ! 426: env->psr |= PSR_NEG; ! 427: if ((src1 & 0xffffffff) < (T1 & 0xffffffff)) ! 428: env->psr |= PSR_CARRY; ! 429: if ((((src1 & 0xffffffff) ^ (T1 & 0xffffffff) ^ -1) & ! 430: ((src1 & 0xffffffff) ^ (T0 & 0xffffffff))) & (1 << 31)) ! 431: env->psr |= PSR_OVF; ! 432: ! 433: env->xcc = 0; ! 434: if (!T0) ! 435: env->xcc |= PSR_ZERO; ! 436: if ((int64_t) T0 < 0) ! 437: env->xcc |= PSR_NEG; ! 438: if (T0 < src1) ! 439: env->xcc |= PSR_CARRY; ! 440: if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1ULL << 63)) ! 441: env->xcc |= PSR_OVF; ! 442: #else ! 443: if (!T0) ! 444: env->psr |= PSR_ZERO; ! 445: if ((int32_t) T0 < 0) ! 446: env->psr |= PSR_NEG; ! 447: if (T0 < src1) ! 448: env->psr |= PSR_CARRY; ! 449: if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1 << 31)) ! 450: env->psr |= PSR_OVF; ! 451: #endif ! 452: FORCE_RET(); ! 453: } ! 454: ! 455: void OPPROTO op_sub_T1_T0(void) ! 456: { ! 457: T0 -= T1; ! 458: } ! 459: ! 460: void OPPROTO op_sub_T1_T0_cc(void) ! 461: { ! 462: target_ulong src1; ! 463: ! 464: src1 = T0; ! 465: T0 -= T1; ! 466: env->psr = 0; ! 467: #ifdef TARGET_SPARC64 ! 468: if (!(T0 & 0xffffffff)) ! 469: env->psr |= PSR_ZERO; ! 470: if ((int32_t) T0 < 0) ! 471: env->psr |= PSR_NEG; ! 472: if ((src1 & 0xffffffff) < (T1 & 0xffffffff)) ! 473: env->psr |= PSR_CARRY; ! 474: if ((((src1 & 0xffffffff) ^ (T1 & 0xffffffff)) & ! 475: ((src1 & 0xffffffff) ^ (T0 & 0xffffffff))) & (1 << 31)) ! 476: env->psr |= PSR_OVF; ! 477: ! 478: env->xcc = 0; ! 479: if (!T0) ! 480: env->xcc |= PSR_ZERO; ! 481: if ((int64_t) T0 < 0) ! 482: env->xcc |= PSR_NEG; ! 483: if (T0 < src1) ! 484: env->xcc |= PSR_CARRY; ! 485: if (((src1 ^ T1) & (src1 ^ T0)) & (1ULL << 63)) ! 486: env->xcc |= PSR_OVF; ! 487: #else ! 488: if (!T0) ! 489: env->psr |= PSR_ZERO; ! 490: if ((int32_t) T0 < 0) ! 491: env->psr |= PSR_NEG; ! 492: if (src1 < T1) ! 493: env->psr |= PSR_CARRY; ! 494: if (((src1 ^ T1) & (src1 ^ T0)) & (1 << 31)) ! 495: env->psr |= PSR_OVF; ! 496: #endif ! 497: FORCE_RET(); ! 498: } ! 499: ! 500: void OPPROTO op_subx_T1_T0(void) ! 501: { ! 502: T0 -= T1 + FLAG_SET(PSR_CARRY); ! 503: } ! 504: ! 505: void OPPROTO op_subx_T1_T0_cc(void) ! 506: { ! 507: target_ulong src1; ! 508: ! 509: src1 = T0; ! 510: T0 -= T1 + FLAG_SET(PSR_CARRY); ! 511: env->psr = 0; ! 512: #ifdef TARGET_SPARC64 ! 513: if (!(T0 & 0xffffffff)) ! 514: env->psr |= PSR_ZERO; ! 515: if ((int32_t) T0 < 0) ! 516: env->psr |= PSR_NEG; ! 517: if ((src1 & 0xffffffff) < (T1 & 0xffffffff)) ! 518: env->psr |= PSR_CARRY; ! 519: if ((((src1 & 0xffffffff) ^ (T1 & 0xffffffff)) & ! 520: ((src1 & 0xffffffff) ^ (T0 & 0xffffffff))) & (1 << 31)) ! 521: env->psr |= PSR_OVF; ! 522: ! 523: env->xcc = 0; ! 524: if (!T0) ! 525: env->xcc |= PSR_ZERO; ! 526: if ((int64_t) T0 < 0) ! 527: env->xcc |= PSR_NEG; ! 528: if (T0 < src1) ! 529: env->xcc |= PSR_CARRY; ! 530: if (((src1 ^ T1) & (src1 ^ T0)) & (1ULL << 63)) ! 531: env->xcc |= PSR_OVF; ! 532: #else ! 533: if (!T0) ! 534: env->psr |= PSR_ZERO; ! 535: if ((int32_t) T0 < 0) ! 536: env->psr |= PSR_NEG; ! 537: if (src1 < T1) ! 538: env->psr |= PSR_CARRY; ! 539: if (((src1 ^ T1) & (src1 ^ T0)) & (1 << 31)) ! 540: env->psr |= PSR_OVF; ! 541: #endif ! 542: FORCE_RET(); ! 543: } ! 544: ! 545: void OPPROTO op_and_T1_T0(void) ! 546: { ! 547: T0 &= T1; ! 548: } ! 549: ! 550: void OPPROTO op_or_T1_T0(void) ! 551: { ! 552: T0 |= T1; ! 553: } ! 554: ! 555: void OPPROTO op_xor_T1_T0(void) ! 556: { ! 557: T0 ^= T1; ! 558: } ! 559: ! 560: void OPPROTO op_andn_T1_T0(void) ! 561: { ! 562: T0 &= ~T1; ! 563: } ! 564: ! 565: void OPPROTO op_orn_T1_T0(void) ! 566: { ! 567: T0 |= ~T1; ! 568: } ! 569: ! 570: void OPPROTO op_xnor_T1_T0(void) ! 571: { ! 572: T0 ^= ~T1; ! 573: } ! 574: ! 575: void OPPROTO op_umul_T1_T0(void) ! 576: { ! 577: uint64_t res; ! 578: res = (uint64_t) T0 * (uint64_t) T1; ! 579: #ifdef TARGET_SPARC64 ! 580: T0 = res; ! 581: #else ! 582: T0 = res & 0xffffffff; ! 583: #endif ! 584: env->y = res >> 32; ! 585: } ! 586: ! 587: void OPPROTO op_smul_T1_T0(void) ! 588: { ! 589: uint64_t res; ! 590: res = (int64_t) ((int32_t) T0) * (int64_t) ((int32_t) T1); ! 591: #ifdef TARGET_SPARC64 ! 592: T0 = res; ! 593: #else ! 594: T0 = res & 0xffffffff; ! 595: #endif ! 596: env->y = res >> 32; ! 597: } ! 598: ! 599: void OPPROTO op_mulscc_T1_T0(void) ! 600: { ! 601: unsigned int b1, N, V, b2; ! 602: target_ulong src1; ! 603: ! 604: N = FLAG_SET(PSR_NEG); ! 605: V = FLAG_SET(PSR_OVF); ! 606: b1 = N ^ V; ! 607: b2 = T0 & 1; ! 608: T0 = (b1 << 31) | (T0 >> 1); ! 609: if (!(env->y & 1)) ! 610: T1 = 0; ! 611: /* do addition and update flags */ ! 612: src1 = T0; ! 613: T0 += T1; ! 614: env->psr = 0; ! 615: if (!T0) ! 616: env->psr |= PSR_ZERO; ! 617: if ((int32_t) T0 < 0) ! 618: env->psr |= PSR_NEG; ! 619: if (T0 < src1) ! 620: env->psr |= PSR_CARRY; ! 621: if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1 << 31)) ! 622: env->psr |= PSR_OVF; ! 623: env->y = (b2 << 31) | (env->y >> 1); ! 624: FORCE_RET(); ! 625: } ! 626: ! 627: void OPPROTO op_udiv_T1_T0(void) ! 628: { ! 629: uint64_t x0; ! 630: uint32_t x1; ! 631: ! 632: x0 = T0 | ((uint64_t) (env->y) << 32); ! 633: x1 = T1; ! 634: x0 = x0 / x1; ! 635: if (x0 > 0xffffffff) { ! 636: T0 = 0xffffffff; ! 637: T1 = 1; ! 638: } else { ! 639: T0 = x0; ! 640: T1 = 0; ! 641: } ! 642: FORCE_RET(); ! 643: } ! 644: ! 645: void OPPROTO op_sdiv_T1_T0(void) ! 646: { ! 647: int64_t x0; ! 648: int32_t x1; ! 649: ! 650: x0 = T0 | ((int64_t) (env->y) << 32); ! 651: x1 = T1; ! 652: x0 = x0 / x1; ! 653: if ((int32_t) x0 != x0) { ! 654: T0 = x0 < 0? 0x80000000: 0x7fffffff; ! 655: T1 = 1; ! 656: } else { ! 657: T0 = x0; ! 658: T1 = 0; ! 659: } ! 660: FORCE_RET(); ! 661: } ! 662: ! 663: void OPPROTO op_div_cc(void) ! 664: { ! 665: env->psr = 0; ! 666: #ifdef TARGET_SPARC64 ! 667: if (!T0) ! 668: env->psr |= PSR_ZERO; ! 669: if ((int32_t) T0 < 0) ! 670: env->psr |= PSR_NEG; ! 671: if (T1) ! 672: env->psr |= PSR_OVF; ! 673: ! 674: env->xcc = 0; ! 675: if (!T0) ! 676: env->xcc |= PSR_ZERO; ! 677: if ((int64_t) T0 < 0) ! 678: env->xcc |= PSR_NEG; ! 679: #else ! 680: if (!T0) ! 681: env->psr |= PSR_ZERO; ! 682: if ((int32_t) T0 < 0) ! 683: env->psr |= PSR_NEG; ! 684: if (T1) ! 685: env->psr |= PSR_OVF; ! 686: #endif ! 687: FORCE_RET(); ! 688: } ! 689: ! 690: #ifdef TARGET_SPARC64 ! 691: void OPPROTO op_mulx_T1_T0(void) ! 692: { ! 693: T0 *= T1; ! 694: FORCE_RET(); ! 695: } ! 696: ! 697: void OPPROTO op_udivx_T1_T0(void) ! 698: { ! 699: T0 /= T1; ! 700: FORCE_RET(); ! 701: } ! 702: ! 703: void OPPROTO op_sdivx_T1_T0(void) ! 704: { ! 705: if (T0 == INT64_MIN && T1 == -1) ! 706: T0 = INT64_MIN; ! 707: else ! 708: T0 /= (target_long) T1; ! 709: FORCE_RET(); ! 710: } ! 711: #endif ! 712: ! 713: void OPPROTO op_logic_T0_cc(void) ! 714: { ! 715: env->psr = 0; ! 716: #ifdef TARGET_SPARC64 ! 717: if (!(T0 & 0xffffffff)) ! 718: env->psr |= PSR_ZERO; ! 719: if ((int32_t) T0 < 0) ! 720: env->psr |= PSR_NEG; ! 721: ! 722: env->xcc = 0; ! 723: if (!T0) ! 724: env->xcc |= PSR_ZERO; ! 725: if ((int64_t) T0 < 0) ! 726: env->xcc |= PSR_NEG; ! 727: #else ! 728: if (!T0) ! 729: env->psr |= PSR_ZERO; ! 730: if ((int32_t) T0 < 0) ! 731: env->psr |= PSR_NEG; ! 732: #endif ! 733: FORCE_RET(); ! 734: } ! 735: ! 736: void OPPROTO op_sll(void) ! 737: { ! 738: T0 <<= T1; ! 739: } ! 740: ! 741: #ifdef TARGET_SPARC64 ! 742: void OPPROTO op_srl(void) ! 743: { ! 744: T0 = (T0 & 0xffffffff) >> T1; ! 745: } ! 746: ! 747: void OPPROTO op_srlx(void) ! 748: { ! 749: T0 >>= T1; ! 750: } ! 751: ! 752: void OPPROTO op_sra(void) ! 753: { ! 754: T0 = ((int32_t) (T0 & 0xffffffff)) >> T1; ! 755: } ! 756: ! 757: void OPPROTO op_srax(void) ! 758: { ! 759: T0 = ((int64_t) T0) >> T1; ! 760: } ! 761: #else ! 762: void OPPROTO op_srl(void) ! 763: { ! 764: T0 >>= T1; ! 765: } ! 766: ! 767: void OPPROTO op_sra(void) ! 768: { ! 769: T0 = ((int32_t) T0) >> T1; ! 770: } ! 771: #endif ! 772: ! 773: /* Load and store */ ! 774: #define MEMSUFFIX _raw ! 775: #include "op_mem.h" ! 776: #if !defined(CONFIG_USER_ONLY) ! 777: #define MEMSUFFIX _user ! 778: #include "op_mem.h" ! 779: ! 780: #define MEMSUFFIX _kernel ! 781: #include "op_mem.h" ! 782: #endif ! 783: ! 784: void OPPROTO op_ldfsr(void) ! 785: { ! 786: PUT_FSR32(env, *((uint32_t *) &FT0)); ! 787: helper_ldfsr(); ! 788: } ! 789: ! 790: void OPPROTO op_stfsr(void) ! 791: { ! 792: *((uint32_t *) &FT0) = GET_FSR32(env); ! 793: } ! 794: ! 795: #ifndef TARGET_SPARC64 ! 796: void OPPROTO op_rdpsr(void) ! 797: { ! 798: do_rdpsr(); ! 799: } ! 800: ! 801: void OPPROTO op_wrpsr(void) ! 802: { ! 803: do_wrpsr(); ! 804: FORCE_RET(); ! 805: } ! 806: ! 807: void OPPROTO op_rett(void) ! 808: { ! 809: helper_rett(); ! 810: FORCE_RET(); ! 811: } ! 812: ! 813: /* XXX: use another pointer for %iN registers to avoid slow wrapping ! 814: handling ? */ ! 815: void OPPROTO op_save(void) ! 816: { ! 817: uint32_t cwp; ! 818: cwp = (env->cwp - 1) & (NWINDOWS - 1); ! 819: if (env->wim & (1 << cwp)) { ! 820: raise_exception(TT_WIN_OVF); ! 821: } ! 822: set_cwp(cwp); ! 823: FORCE_RET(); ! 824: } ! 825: ! 826: void OPPROTO op_restore(void) ! 827: { ! 828: uint32_t cwp; ! 829: cwp = (env->cwp + 1) & (NWINDOWS - 1); ! 830: if (env->wim & (1 << cwp)) { ! 831: raise_exception(TT_WIN_UNF); ! 832: } ! 833: set_cwp(cwp); ! 834: FORCE_RET(); ! 835: } ! 836: #else ! 837: void OPPROTO op_rdccr(void) ! 838: { ! 839: T0 = GET_CCR(env); ! 840: } ! 841: ! 842: void OPPROTO op_wrccr(void) ! 843: { ! 844: PUT_CCR(env, T0); ! 845: } ! 846: ! 847: void OPPROTO op_rdtick(void) ! 848: { ! 849: T0 = 0; // XXX read cycle counter and bit 31 ! 850: } ! 851: ! 852: void OPPROTO op_wrtick(void) ! 853: { ! 854: // XXX write cycle counter and bit 31 ! 855: } ! 856: ! 857: void OPPROTO op_rdtpc(void) ! 858: { ! 859: T0 = env->tpc[env->tl]; ! 860: } ! 861: ! 862: void OPPROTO op_wrtpc(void) ! 863: { ! 864: env->tpc[env->tl] = T0; ! 865: } ! 866: ! 867: void OPPROTO op_rdtnpc(void) ! 868: { ! 869: T0 = env->tnpc[env->tl]; ! 870: } ! 871: ! 872: void OPPROTO op_wrtnpc(void) ! 873: { ! 874: env->tnpc[env->tl] = T0; ! 875: } ! 876: ! 877: void OPPROTO op_rdtstate(void) ! 878: { ! 879: T0 = env->tstate[env->tl]; ! 880: } ! 881: ! 882: void OPPROTO op_wrtstate(void) ! 883: { ! 884: env->tstate[env->tl] = T0; ! 885: } ! 886: ! 887: void OPPROTO op_rdtt(void) ! 888: { ! 889: T0 = env->tt[env->tl]; ! 890: } ! 891: ! 892: void OPPROTO op_wrtt(void) ! 893: { ! 894: env->tt[env->tl] = T0; ! 895: } ! 896: ! 897: void OPPROTO op_rdpstate(void) ! 898: { ! 899: T0 = env->pstate; ! 900: } ! 901: ! 902: void OPPROTO op_wrpstate(void) ! 903: { ! 904: do_wrpstate(); ! 905: } ! 906: ! 907: // CWP handling is reversed in V9, but we still use the V8 register ! 908: // order. ! 909: void OPPROTO op_rdcwp(void) ! 910: { ! 911: T0 = NWINDOWS - 1 - env->cwp; ! 912: } ! 913: ! 914: void OPPROTO op_wrcwp(void) ! 915: { ! 916: env->cwp = NWINDOWS - 1 - T0; ! 917: } ! 918: ! 919: /* XXX: use another pointer for %iN registers to avoid slow wrapping ! 920: handling ? */ ! 921: void OPPROTO op_save(void) ! 922: { ! 923: uint32_t cwp; ! 924: cwp = (env->cwp - 1) & (NWINDOWS - 1); ! 925: if (env->cansave == 0) { ! 926: raise_exception(TT_SPILL | (env->otherwin != 0 ? ! 927: (TT_WOTHER | ((env->wstate & 0x38) >> 1)): ! 928: ((env->wstate & 0x7) << 2))); ! 929: } else { ! 930: if (env->cleanwin - env->canrestore == 0) { ! 931: // XXX Clean windows without trap ! 932: raise_exception(TT_CLRWIN); ! 933: } else { ! 934: env->cansave--; ! 935: env->canrestore++; ! 936: set_cwp(cwp); ! 937: } ! 938: } ! 939: FORCE_RET(); ! 940: } ! 941: ! 942: void OPPROTO op_restore(void) ! 943: { ! 944: uint32_t cwp; ! 945: cwp = (env->cwp + 1) & (NWINDOWS - 1); ! 946: if (env->canrestore == 0) { ! 947: raise_exception(TT_FILL | (env->otherwin != 0 ? ! 948: (TT_WOTHER | ((env->wstate & 0x38) >> 1)): ! 949: ((env->wstate & 0x7) << 2))); ! 950: } else { ! 951: env->cansave++; ! 952: env->canrestore--; ! 953: set_cwp(cwp); ! 954: } ! 955: FORCE_RET(); ! 956: } ! 957: #endif ! 958: ! 959: void OPPROTO op_exception(void) ! 960: { ! 961: env->exception_index = PARAM1; ! 962: cpu_loop_exit(); ! 963: } ! 964: ! 965: void OPPROTO op_trap_T0(void) ! 966: { ! 967: env->exception_index = TT_TRAP + (T0 & 0x7f); ! 968: cpu_loop_exit(); ! 969: } ! 970: ! 971: void OPPROTO op_trapcc_T0(void) ! 972: { ! 973: if (T2) { ! 974: env->exception_index = TT_TRAP + (T0 & 0x7f); ! 975: cpu_loop_exit(); ! 976: } ! 977: FORCE_RET(); ! 978: } ! 979: ! 980: void OPPROTO op_trap_ifnofpu(void) ! 981: { ! 982: if (!env->psref) { ! 983: env->exception_index = TT_NFPU_INSN; ! 984: cpu_loop_exit(); ! 985: } ! 986: FORCE_RET(); ! 987: } ! 988: ! 989: void OPPROTO op_fpexception_im(void) ! 990: { ! 991: env->exception_index = TT_FP_EXCP; ! 992: env->fsr &= ~FSR_FTT_MASK; ! 993: env->fsr |= PARAM1; ! 994: cpu_loop_exit(); ! 995: FORCE_RET(); ! 996: } ! 997: ! 998: void OPPROTO op_debug(void) ! 999: { ! 1000: helper_debug(); ! 1001: } ! 1002: ! 1003: void OPPROTO op_exit_tb(void) ! 1004: { ! 1005: EXIT_TB(); ! 1006: } ! 1007: ! 1008: void OPPROTO op_eval_ba(void) ! 1009: { ! 1010: T2 = 1; ! 1011: } ! 1012: ! 1013: void OPPROTO op_eval_be(void) ! 1014: { ! 1015: T2 = FLAG_SET(PSR_ZERO); ! 1016: } ! 1017: ! 1018: void OPPROTO op_eval_ble(void) ! 1019: { ! 1020: target_ulong Z = FLAG_SET(PSR_ZERO), N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF); ! 1021: ! 1022: T2 = Z | (N ^ V); ! 1023: } ! 1024: ! 1025: void OPPROTO op_eval_bl(void) ! 1026: { ! 1027: target_ulong N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF); ! 1028: ! 1029: T2 = N ^ V; ! 1030: } ! 1031: ! 1032: void OPPROTO op_eval_bleu(void) ! 1033: { ! 1034: target_ulong Z = FLAG_SET(PSR_ZERO), C = FLAG_SET(PSR_CARRY); ! 1035: ! 1036: T2 = C | Z; ! 1037: } ! 1038: ! 1039: void OPPROTO op_eval_bcs(void) ! 1040: { ! 1041: T2 = FLAG_SET(PSR_CARRY); ! 1042: } ! 1043: ! 1044: void OPPROTO op_eval_bvs(void) ! 1045: { ! 1046: T2 = FLAG_SET(PSR_OVF); ! 1047: } ! 1048: ! 1049: void OPPROTO op_eval_bn(void) ! 1050: { ! 1051: T2 = 0; ! 1052: } ! 1053: ! 1054: void OPPROTO op_eval_bneg(void) ! 1055: { ! 1056: T2 = FLAG_SET(PSR_NEG); ! 1057: } ! 1058: ! 1059: void OPPROTO op_eval_bne(void) ! 1060: { ! 1061: T2 = !FLAG_SET(PSR_ZERO); ! 1062: } ! 1063: ! 1064: void OPPROTO op_eval_bg(void) ! 1065: { ! 1066: target_ulong Z = FLAG_SET(PSR_ZERO), N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF); ! 1067: ! 1068: T2 = !(Z | (N ^ V)); ! 1069: } ! 1070: ! 1071: void OPPROTO op_eval_bge(void) ! 1072: { ! 1073: target_ulong N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF); ! 1074: ! 1075: T2 = !(N ^ V); ! 1076: } ! 1077: ! 1078: void OPPROTO op_eval_bgu(void) ! 1079: { ! 1080: target_ulong Z = FLAG_SET(PSR_ZERO), C = FLAG_SET(PSR_CARRY); ! 1081: ! 1082: T2 = !(C | Z); ! 1083: } ! 1084: ! 1085: void OPPROTO op_eval_bcc(void) ! 1086: { ! 1087: T2 = !FLAG_SET(PSR_CARRY); ! 1088: } ! 1089: ! 1090: void OPPROTO op_eval_bpos(void) ! 1091: { ! 1092: T2 = !FLAG_SET(PSR_NEG); ! 1093: } ! 1094: ! 1095: void OPPROTO op_eval_bvc(void) ! 1096: { ! 1097: T2 = !FLAG_SET(PSR_OVF); ! 1098: } ! 1099: ! 1100: #ifdef TARGET_SPARC64 ! 1101: void OPPROTO op_eval_xbe(void) ! 1102: { ! 1103: T2 = XFLAG_SET(PSR_ZERO); ! 1104: } ! 1105: ! 1106: void OPPROTO op_eval_xble(void) ! 1107: { ! 1108: target_ulong Z = XFLAG_SET(PSR_ZERO), N = XFLAG_SET(PSR_NEG), V = XFLAG_SET(PSR_OVF); ! 1109: ! 1110: T2 = Z | (N ^ V); ! 1111: } ! 1112: ! 1113: void OPPROTO op_eval_xbl(void) ! 1114: { ! 1115: target_ulong N = XFLAG_SET(PSR_NEG), V = XFLAG_SET(PSR_OVF); ! 1116: ! 1117: T2 = N ^ V; ! 1118: } ! 1119: ! 1120: void OPPROTO op_eval_xbleu(void) ! 1121: { ! 1122: target_ulong Z = XFLAG_SET(PSR_ZERO), C = XFLAG_SET(PSR_CARRY); ! 1123: ! 1124: T2 = C | Z; ! 1125: } ! 1126: ! 1127: void OPPROTO op_eval_xbcs(void) ! 1128: { ! 1129: T2 = XFLAG_SET(PSR_CARRY); ! 1130: } ! 1131: ! 1132: void OPPROTO op_eval_xbvs(void) ! 1133: { ! 1134: T2 = XFLAG_SET(PSR_OVF); ! 1135: } ! 1136: ! 1137: void OPPROTO op_eval_xbneg(void) ! 1138: { ! 1139: T2 = XFLAG_SET(PSR_NEG); ! 1140: } ! 1141: ! 1142: void OPPROTO op_eval_xbne(void) ! 1143: { ! 1144: T2 = !XFLAG_SET(PSR_ZERO); ! 1145: } ! 1146: ! 1147: void OPPROTO op_eval_xbg(void) ! 1148: { ! 1149: target_ulong Z = XFLAG_SET(PSR_ZERO), N = XFLAG_SET(PSR_NEG), V = XFLAG_SET(PSR_OVF); ! 1150: ! 1151: T2 = !(Z | (N ^ V)); ! 1152: } ! 1153: ! 1154: void OPPROTO op_eval_xbge(void) ! 1155: { ! 1156: target_ulong N = XFLAG_SET(PSR_NEG), V = XFLAG_SET(PSR_OVF); ! 1157: ! 1158: T2 = !(N ^ V); ! 1159: } ! 1160: ! 1161: void OPPROTO op_eval_xbgu(void) ! 1162: { ! 1163: target_ulong Z = XFLAG_SET(PSR_ZERO), C = XFLAG_SET(PSR_CARRY); ! 1164: ! 1165: T2 = !(C | Z); ! 1166: } ! 1167: ! 1168: void OPPROTO op_eval_xbcc(void) ! 1169: { ! 1170: T2 = !XFLAG_SET(PSR_CARRY); ! 1171: } ! 1172: ! 1173: void OPPROTO op_eval_xbpos(void) ! 1174: { ! 1175: T2 = !XFLAG_SET(PSR_NEG); ! 1176: } ! 1177: ! 1178: void OPPROTO op_eval_xbvc(void) ! 1179: { ! 1180: T2 = !XFLAG_SET(PSR_OVF); ! 1181: } ! 1182: #endif ! 1183: ! 1184: #define FCC ! 1185: #define FFLAG_SET(x) (env->fsr & x? 1: 0) ! 1186: #include "fbranch_template.h" ! 1187: ! 1188: #ifdef TARGET_SPARC64 ! 1189: #define FCC _fcc1 ! 1190: #define FFLAG_SET(x) ((env->fsr & ((uint64_t)x >> 32))? 1: 0) ! 1191: #include "fbranch_template.h" ! 1192: #define FCC _fcc2 ! 1193: #define FFLAG_SET(x) ((env->fsr & ((uint64_t)x >> 34))? 1: 0) ! 1194: #include "fbranch_template.h" ! 1195: #define FCC _fcc3 ! 1196: #define FFLAG_SET(x) ((env->fsr & ((uint64_t)x >> 36))? 1: 0) ! 1197: #include "fbranch_template.h" ! 1198: #endif ! 1199: ! 1200: #ifdef TARGET_SPARC64 ! 1201: void OPPROTO op_eval_brz(void) ! 1202: { ! 1203: T2 = (T0 == 0); ! 1204: } ! 1205: ! 1206: void OPPROTO op_eval_brnz(void) ! 1207: { ! 1208: T2 = (T0 != 0); ! 1209: } ! 1210: ! 1211: void OPPROTO op_eval_brlz(void) ! 1212: { ! 1213: T2 = ((int64_t)T0 < 0); ! 1214: } ! 1215: ! 1216: void OPPROTO op_eval_brlez(void) ! 1217: { ! 1218: T2 = ((int64_t)T0 <= 0); ! 1219: } ! 1220: ! 1221: void OPPROTO op_eval_brgz(void) ! 1222: { ! 1223: T2 = ((int64_t)T0 > 0); ! 1224: } ! 1225: ! 1226: void OPPROTO op_eval_brgez(void) ! 1227: { ! 1228: T2 = ((int64_t)T0 >= 0); ! 1229: } ! 1230: ! 1231: void OPPROTO op_jmp_im64(void) ! 1232: { ! 1233: env->pc = PARAMQ1; ! 1234: } ! 1235: ! 1236: void OPPROTO op_movq_npc_im64(void) ! 1237: { ! 1238: env->npc = PARAMQ1; ! 1239: } ! 1240: #endif ! 1241: ! 1242: void OPPROTO op_jmp_im(void) ! 1243: { ! 1244: env->pc = (uint32_t)PARAM1; ! 1245: } ! 1246: ! 1247: void OPPROTO op_movl_npc_im(void) ! 1248: { ! 1249: env->npc = (uint32_t)PARAM1; ! 1250: } ! 1251: ! 1252: void OPPROTO op_movl_npc_T0(void) ! 1253: { ! 1254: env->npc = T0; ! 1255: } ! 1256: ! 1257: void OPPROTO op_mov_pc_npc(void) ! 1258: { ! 1259: env->pc = env->npc; ! 1260: } ! 1261: ! 1262: void OPPROTO op_next_insn(void) ! 1263: { ! 1264: env->pc = env->npc; ! 1265: env->npc = env->npc + 4; ! 1266: } ! 1267: ! 1268: void OPPROTO op_goto_tb0(void) ! 1269: { ! 1270: GOTO_TB(op_goto_tb0, PARAM1, 0); ! 1271: } ! 1272: ! 1273: void OPPROTO op_goto_tb1(void) ! 1274: { ! 1275: GOTO_TB(op_goto_tb1, PARAM1, 1); ! 1276: } ! 1277: ! 1278: void OPPROTO op_jmp_label(void) ! 1279: { ! 1280: GOTO_LABEL_PARAM(1); ! 1281: } ! 1282: ! 1283: void OPPROTO op_jnz_T2_label(void) ! 1284: { ! 1285: if (T2) ! 1286: GOTO_LABEL_PARAM(1); ! 1287: FORCE_RET(); ! 1288: } ! 1289: ! 1290: void OPPROTO op_jz_T2_label(void) ! 1291: { ! 1292: if (!T2) ! 1293: GOTO_LABEL_PARAM(1); ! 1294: FORCE_RET(); ! 1295: } ! 1296: ! 1297: void OPPROTO op_flush_T0(void) ! 1298: { ! 1299: helper_flush(T0); ! 1300: } ! 1301: ! 1302: void OPPROTO op_fnegs(void) ! 1303: { ! 1304: FT0 = -FT1; ! 1305: } ! 1306: ! 1307: void OPPROTO op_fabss(void) ! 1308: { ! 1309: do_fabss(); ! 1310: } ! 1311: ! 1312: #ifdef TARGET_SPARC64 ! 1313: void OPPROTO op_fnegd(void) ! 1314: { ! 1315: DT0 = -DT1; ! 1316: } ! 1317: ! 1318: void OPPROTO op_fabsd(void) ! 1319: { ! 1320: do_fabsd(); ! 1321: } ! 1322: #endif ! 1323: ! 1324: void OPPROTO op_fsqrts(void) ! 1325: { ! 1326: do_fsqrts(); ! 1327: } ! 1328: ! 1329: void OPPROTO op_fsqrtd(void) ! 1330: { ! 1331: do_fsqrtd(); ! 1332: } ! 1333: ! 1334: void OPPROTO op_fmuls(void) ! 1335: { ! 1336: FT0 *= FT1; ! 1337: } ! 1338: ! 1339: void OPPROTO op_fmuld(void) ! 1340: { ! 1341: DT0 *= DT1; ! 1342: } ! 1343: ! 1344: void OPPROTO op_fsmuld(void) ! 1345: { ! 1346: DT0 = FT0 * FT1; ! 1347: } ! 1348: ! 1349: void OPPROTO op_fadds(void) ! 1350: { ! 1351: FT0 += FT1; ! 1352: } ! 1353: ! 1354: void OPPROTO op_faddd(void) ! 1355: { ! 1356: DT0 += DT1; ! 1357: } ! 1358: ! 1359: void OPPROTO op_fsubs(void) ! 1360: { ! 1361: FT0 -= FT1; ! 1362: } ! 1363: ! 1364: void OPPROTO op_fsubd(void) ! 1365: { ! 1366: DT0 -= DT1; ! 1367: } ! 1368: ! 1369: void OPPROTO op_fdivs(void) ! 1370: { ! 1371: FT0 /= FT1; ! 1372: } ! 1373: ! 1374: void OPPROTO op_fdivd(void) ! 1375: { ! 1376: DT0 /= DT1; ! 1377: } ! 1378: ! 1379: void OPPROTO op_fcmps(void) ! 1380: { ! 1381: do_fcmps(); ! 1382: } ! 1383: ! 1384: void OPPROTO op_fcmpd(void) ! 1385: { ! 1386: do_fcmpd(); ! 1387: } ! 1388: ! 1389: #ifdef TARGET_SPARC64 ! 1390: void OPPROTO op_fcmps_fcc1(void) ! 1391: { ! 1392: do_fcmps_fcc1(); ! 1393: } ! 1394: ! 1395: void OPPROTO op_fcmpd_fcc1(void) ! 1396: { ! 1397: do_fcmpd_fcc1(); ! 1398: } ! 1399: ! 1400: void OPPROTO op_fcmps_fcc2(void) ! 1401: { ! 1402: do_fcmps_fcc2(); ! 1403: } ! 1404: ! 1405: void OPPROTO op_fcmpd_fcc2(void) ! 1406: { ! 1407: do_fcmpd_fcc2(); ! 1408: } ! 1409: ! 1410: void OPPROTO op_fcmps_fcc3(void) ! 1411: { ! 1412: do_fcmps_fcc3(); ! 1413: } ! 1414: ! 1415: void OPPROTO op_fcmpd_fcc3(void) ! 1416: { ! 1417: do_fcmpd_fcc3(); ! 1418: } ! 1419: #endif ! 1420: ! 1421: #ifdef USE_INT_TO_FLOAT_HELPERS ! 1422: void OPPROTO op_fitos(void) ! 1423: { ! 1424: do_fitos(); ! 1425: } ! 1426: ! 1427: void OPPROTO op_fitod(void) ! 1428: { ! 1429: do_fitod(); ! 1430: } ! 1431: #else ! 1432: void OPPROTO op_fitos(void) ! 1433: { ! 1434: FT0 = (float) *((int32_t *)&FT1); ! 1435: } ! 1436: ! 1437: void OPPROTO op_fitod(void) ! 1438: { ! 1439: DT0 = (double) *((int32_t *)&FT1); ! 1440: } ! 1441: ! 1442: #ifdef TARGET_SPARC64 ! 1443: void OPPROTO op_fxtos(void) ! 1444: { ! 1445: FT0 = (float) *((int64_t *)&DT1); ! 1446: } ! 1447: ! 1448: void OPPROTO op_fxtod(void) ! 1449: { ! 1450: DT0 = (double) *((int64_t *)&DT1); ! 1451: } ! 1452: #endif ! 1453: #endif ! 1454: ! 1455: void OPPROTO op_fdtos(void) ! 1456: { ! 1457: FT0 = (float) DT1; ! 1458: } ! 1459: ! 1460: void OPPROTO op_fstod(void) ! 1461: { ! 1462: DT0 = (double) FT1; ! 1463: } ! 1464: ! 1465: void OPPROTO op_fstoi(void) ! 1466: { ! 1467: *((int32_t *)&FT0) = (int32_t) FT1; ! 1468: } ! 1469: ! 1470: void OPPROTO op_fdtoi(void) ! 1471: { ! 1472: *((int32_t *)&FT0) = (int32_t) DT1; ! 1473: } ! 1474: ! 1475: #ifdef TARGET_SPARC64 ! 1476: void OPPROTO op_fstox(void) ! 1477: { ! 1478: *((int64_t *)&DT0) = (int64_t) FT1; ! 1479: } ! 1480: ! 1481: void OPPROTO op_fdtox(void) ! 1482: { ! 1483: *((int64_t *)&DT0) = (int64_t) DT1; ! 1484: } ! 1485: ! 1486: void OPPROTO op_fmovs_cc(void) ! 1487: { ! 1488: if (T2) ! 1489: FT0 = FT1; ! 1490: } ! 1491: ! 1492: void OPPROTO op_fmovd_cc(void) ! 1493: { ! 1494: if (T2) ! 1495: DT0 = DT1; ! 1496: } ! 1497: ! 1498: void OPPROTO op_mov_cc(void) ! 1499: { ! 1500: if (T2) ! 1501: T0 = T1; ! 1502: } ! 1503: ! 1504: void OPPROTO op_flushw(void) ! 1505: { ! 1506: if (env->cansave != NWINDOWS - 2) { ! 1507: raise_exception(TT_SPILL | (env->otherwin != 0 ? ! 1508: (TT_WOTHER | ((env->wstate & 0x38) >> 1)): ! 1509: ((env->wstate & 0x7) << 2))); ! 1510: } ! 1511: } ! 1512: ! 1513: void OPPROTO op_saved(void) ! 1514: { ! 1515: env->cansave++; ! 1516: if (env->otherwin == 0) ! 1517: env->canrestore--; ! 1518: } ! 1519: ! 1520: void OPPROTO op_restored(void) ! 1521: { ! 1522: env->canrestore++; ! 1523: if (env->cleanwin < NWINDOWS - 1) ! 1524: env->cleanwin++; ! 1525: if (env->otherwin == 0) ! 1526: env->cansave--; ! 1527: else ! 1528: env->otherwin--; ! 1529: } ! 1530: ! 1531: void OPPROTO op_popc(void) ! 1532: { ! 1533: do_popc(); ! 1534: } ! 1535: ! 1536: void OPPROTO op_done(void) ! 1537: { ! 1538: do_done(); ! 1539: } ! 1540: ! 1541: void OPPROTO op_retry(void) ! 1542: { ! 1543: do_retry(); ! 1544: } ! 1545: ! 1546: void OPPROTO op_sir(void) ! 1547: { ! 1548: // XXX ! 1549: ! 1550: } ! 1551: ! 1552: void OPPROTO op_ld_asi_reg() ! 1553: { ! 1554: T0 += PARAM1; ! 1555: helper_ld_asi(env->asi, PARAM2, PARAM3); ! 1556: } ! 1557: ! 1558: void OPPROTO op_st_asi_reg() ! 1559: { ! 1560: T0 += PARAM1; ! 1561: helper_st_asi(env->asi, PARAM2, PARAM3); ! 1562: } ! 1563: #endif ! 1564: ! 1565: void OPPROTO op_ld_asi() ! 1566: { ! 1567: helper_ld_asi(PARAM1, PARAM2, PARAM3); ! 1568: } ! 1569: ! 1570: void OPPROTO op_st_asi() ! 1571: { ! 1572: helper_st_asi(PARAM1, PARAM2, PARAM3); ! 1573: } ! 1574:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.