![[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-cris|
Return to op.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / target-cris |
1.1 ! root 1: /* ! 2: * CRIS emulation micro-operations for qemu. ! 3: * ! 4: * Copyright (c) 2007 Edgar E. Iglesias, Axis Communications AB. ! 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: #include "exec.h" ! 21: #include "host-utils.h" ! 22: ! 23: #define REGNAME r0 ! 24: #define REG (env->regs[0]) ! 25: #include "op_template.h" ! 26: ! 27: #define REGNAME r1 ! 28: #define REG (env->regs[1]) ! 29: #include "op_template.h" ! 30: ! 31: #define REGNAME r2 ! 32: #define REG (env->regs[2]) ! 33: #include "op_template.h" ! 34: ! 35: #define REGNAME r3 ! 36: #define REG (env->regs[3]) ! 37: #include "op_template.h" ! 38: ! 39: #define REGNAME r4 ! 40: #define REG (env->regs[4]) ! 41: #include "op_template.h" ! 42: ! 43: #define REGNAME r5 ! 44: #define REG (env->regs[5]) ! 45: #include "op_template.h" ! 46: ! 47: #define REGNAME r6 ! 48: #define REG (env->regs[6]) ! 49: #include "op_template.h" ! 50: ! 51: #define REGNAME r7 ! 52: #define REG (env->regs[7]) ! 53: #include "op_template.h" ! 54: ! 55: #define REGNAME r8 ! 56: #define REG (env->regs[8]) ! 57: #include "op_template.h" ! 58: ! 59: #define REGNAME r9 ! 60: #define REG (env->regs[9]) ! 61: #include "op_template.h" ! 62: ! 63: #define REGNAME r10 ! 64: #define REG (env->regs[10]) ! 65: #include "op_template.h" ! 66: ! 67: #define REGNAME r11 ! 68: #define REG (env->regs[11]) ! 69: #include "op_template.h" ! 70: ! 71: #define REGNAME r12 ! 72: #define REG (env->regs[12]) ! 73: #include "op_template.h" ! 74: ! 75: #define REGNAME r13 ! 76: #define REG (env->regs[13]) ! 77: #include "op_template.h" ! 78: ! 79: #define REGNAME r14 ! 80: #define REG (env->regs[14]) ! 81: #include "op_template.h" ! 82: ! 83: #define REGNAME r15 ! 84: #define REG (env->regs[15]) ! 85: #include "op_template.h" ! 86: ! 87: ! 88: #define REGNAME p0 ! 89: #define REG (env->pregs[0]) ! 90: #include "op_template.h" ! 91: ! 92: #define REGNAME p1 ! 93: #define REG (env->pregs[1]) ! 94: #include "op_template.h" ! 95: ! 96: #define REGNAME p2 ! 97: #define REG (env->pregs[2]) ! 98: #include "op_template.h" ! 99: ! 100: #define REGNAME p3 ! 101: #define REG (env->pregs[3]) ! 102: #include "op_template.h" ! 103: ! 104: #define REGNAME p4 ! 105: #define REG (env->pregs[4]) ! 106: #include "op_template.h" ! 107: ! 108: #define REGNAME p5 ! 109: #define REG (env->pregs[5]) ! 110: #include "op_template.h" ! 111: ! 112: #define REGNAME p6 ! 113: #define REG (env->pregs[6]) ! 114: #include "op_template.h" ! 115: ! 116: #define REGNAME p7 ! 117: #define REG (env->pregs[7]) ! 118: #include "op_template.h" ! 119: ! 120: #define REGNAME p8 ! 121: #define REG (env->pregs[8]) ! 122: #include "op_template.h" ! 123: ! 124: #define REGNAME p9 ! 125: #define REG (env->pregs[9]) ! 126: #include "op_template.h" ! 127: ! 128: #define REGNAME p10 ! 129: #define REG (env->pregs[10]) ! 130: #include "op_template.h" ! 131: ! 132: #define REGNAME p11 ! 133: #define REG (env->pregs[11]) ! 134: #include "op_template.h" ! 135: ! 136: #define REGNAME p12 ! 137: #define REG (env->pregs[12]) ! 138: #include "op_template.h" ! 139: ! 140: #define REGNAME p13 ! 141: #define REG (env->pregs[13]) ! 142: #include "op_template.h" ! 143: ! 144: #define REGNAME p14 ! 145: #define REG (env->pregs[14]) ! 146: #include "op_template.h" ! 147: ! 148: #define REGNAME p15 ! 149: #define REG (env->pregs[15]) ! 150: #include "op_template.h" ! 151: ! 152: /* Microcode. */ ! 153: ! 154: void OPPROTO op_exit_tb (void) ! 155: { ! 156: EXIT_TB(); ! 157: } ! 158: ! 159: void OPPROTO op_goto_tb0 (void) ! 160: { ! 161: GOTO_TB(op_goto_tb0, PARAM1, 0); ! 162: RETURN(); ! 163: } ! 164: ! 165: void OPPROTO op_goto_tb1 (void) ! 166: { ! 167: GOTO_TB(op_goto_tb1, PARAM1, 1); ! 168: RETURN(); ! 169: } ! 170: ! 171: void OPPROTO op_break_im(void) ! 172: { ! 173: env->trapnr = PARAM1; ! 174: env->exception_index = EXCP_BREAK; ! 175: cpu_loop_exit(); ! 176: } ! 177: ! 178: void OPPROTO op_debug(void) ! 179: { ! 180: env->exception_index = EXCP_DEBUG; ! 181: cpu_loop_exit(); ! 182: } ! 183: ! 184: void OPPROTO op_exec_insn(void) ! 185: { ! 186: env->stats.exec_insns++; ! 187: RETURN(); ! 188: } ! 189: void OPPROTO op_exec_load(void) ! 190: { ! 191: env->stats.exec_loads++; ! 192: RETURN(); ! 193: } ! 194: void OPPROTO op_exec_store(void) ! 195: { ! 196: env->stats.exec_stores++; ! 197: RETURN(); ! 198: } ! 199: ! 200: void OPPROTO op_ccs_lshift (void) ! 201: { ! 202: uint32_t ccs; ! 203: ! 204: /* Apply the ccs shift. */ ! 205: ccs = env->pregs[SR_CCS]; ! 206: ccs = (ccs & 0xc0000000) | ((ccs << 12) >> 2); ! 207: env->pregs[SR_CCS] = ccs; ! 208: } ! 209: void OPPROTO op_ccs_rshift (void) ! 210: { ! 211: uint32_t ccs; ! 212: ! 213: /* Apply the ccs shift. */ ! 214: ccs = env->pregs[SR_CCS]; ! 215: ccs = (ccs & 0xc0000000) | (ccs >> 10); ! 216: env->pregs[SR_CCS] = ccs; ! 217: } ! 218: ! 219: void OPPROTO op_setf (void) ! 220: { ! 221: env->pregs[SR_CCS] |= PARAM1; ! 222: RETURN(); ! 223: } ! 224: ! 225: void OPPROTO op_clrf (void) ! 226: { ! 227: env->pregs[SR_CCS] &= ~PARAM1; ! 228: RETURN(); ! 229: } ! 230: ! 231: void OPPROTO op_movl_debug1_T0 (void) ! 232: { ! 233: env->debug1 = T0; ! 234: RETURN(); ! 235: } ! 236: ! 237: void OPPROTO op_movl_debug2_T0 (void) ! 238: { ! 239: env->debug2 = T0; ! 240: RETURN(); ! 241: } ! 242: ! 243: void OPPROTO op_movl_debug3_T0 (void) ! 244: { ! 245: env->debug3 = T0; ! 246: RETURN(); ! 247: } ! 248: void OPPROTO op_movl_debug1_T1 (void) ! 249: { ! 250: env->debug1 = T1; ! 251: RETURN(); ! 252: } ! 253: ! 254: void OPPROTO op_movl_debug2_T1 (void) ! 255: { ! 256: env->debug2 = T1; ! 257: RETURN(); ! 258: } ! 259: ! 260: void OPPROTO op_movl_debug3_T1 (void) ! 261: { ! 262: env->debug3 = T1; ! 263: RETURN(); ! 264: } ! 265: void OPPROTO op_movl_debug3_im (void) ! 266: { ! 267: env->debug3 = PARAM1; ! 268: RETURN(); ! 269: } ! 270: void OPPROTO op_movl_T0_flags (void) ! 271: { ! 272: T0 = env->pregs[SR_CCS]; ! 273: RETURN(); ! 274: } ! 275: void OPPROTO op_movl_flags_T0 (void) ! 276: { ! 277: env->pregs[SR_CCS] = T0; ! 278: RETURN(); ! 279: } ! 280: ! 281: void OPPROTO op_movl_sreg_T0 (void) ! 282: { ! 283: env->sregs[env->pregs[SR_SRS]][PARAM1] = T0; ! 284: RETURN(); ! 285: } ! 286: ! 287: void OPPROTO op_movl_tlb_lo_T0 (void) ! 288: { ! 289: int srs; ! 290: srs = env->pregs[SR_SRS]; ! 291: if (srs == 1 || srs == 2) ! 292: { ! 293: int set; ! 294: int idx; ! 295: uint32_t lo, hi; ! 296: ! 297: idx = set = env->sregs[SFR_RW_MM_TLB_SEL]; ! 298: set >>= 4; ! 299: set &= 3; ! 300: ! 301: idx &= 31; ! 302: /* We've just made a write to tlb_lo. */ ! 303: lo = env->sregs[SFR_RW_MM_TLB_LO]; ! 304: hi = env->sregs[SFR_RW_MM_TLB_HI]; ! 305: env->tlbsets[srs - 1][set][idx].lo = lo; ! 306: env->tlbsets[srs - 1][set][idx].hi = hi; ! 307: } ! 308: ! 309: RETURN(); ! 310: } ! 311: ! 312: void OPPROTO op_movl_T0_sreg (void) ! 313: { ! 314: T0 = env->sregs[env->pregs[SR_SRS]][PARAM1]; ! 315: RETURN(); ! 316: } ! 317: ! 318: void OPPROTO op_update_cc (void) ! 319: { ! 320: env->cc_op = PARAM1; ! 321: env->cc_dest = PARAM2; ! 322: env->cc_src = PARAM3; ! 323: RETURN(); ! 324: } ! 325: ! 326: void OPPROTO op_update_cc_op (void) ! 327: { ! 328: env->cc_op = PARAM1; ! 329: RETURN(); ! 330: } ! 331: ! 332: void OPPROTO op_update_cc_mask (void) ! 333: { ! 334: env->cc_mask = PARAM1; ! 335: RETURN(); ! 336: } ! 337: ! 338: void OPPROTO op_update_cc_dest_T0 (void) ! 339: { ! 340: env->cc_dest = T0; ! 341: RETURN(); ! 342: } ! 343: ! 344: void OPPROTO op_update_cc_result_T0 (void) ! 345: { ! 346: env->cc_result = T0; ! 347: RETURN(); ! 348: } ! 349: ! 350: void OPPROTO op_update_cc_size_im (void) ! 351: { ! 352: env->cc_size = PARAM1; ! 353: RETURN(); ! 354: } ! 355: ! 356: void OPPROTO op_update_cc_src_T1 (void) ! 357: { ! 358: env->cc_src = T1; ! 359: RETURN(); ! 360: } ! 361: void OPPROTO op_update_cc_x (void) ! 362: { ! 363: env->cc_x_live = PARAM1; ! 364: env->cc_x = PARAM2; ! 365: RETURN(); ! 366: } ! 367: ! 368: /* FIXME: is this allowed? */ ! 369: extern inline void evaluate_flags_writeback(uint32_t flags) ! 370: { ! 371: int x; ! 372: ! 373: /* Extended arithmetics, leave the z flag alone. */ ! 374: env->debug3 = env->pregs[SR_CCS]; ! 375: ! 376: if (env->cc_x_live) ! 377: x = env->cc_x; ! 378: else ! 379: x = env->pregs[SR_CCS] & X_FLAG; ! 380: ! 381: if ((x || env->cc_op == CC_OP_ADDC) ! 382: && flags & Z_FLAG) ! 383: env->cc_mask &= ~Z_FLAG; ! 384: ! 385: /* all insn clear the x-flag except setf or clrf. */ ! 386: env->pregs[SR_CCS] &= ~(env->cc_mask | X_FLAG); ! 387: flags &= env->cc_mask; ! 388: env->pregs[SR_CCS] |= flags; ! 389: RETURN(); ! 390: } ! 391: ! 392: void OPPROTO op_evaluate_flags_muls(void) ! 393: { ! 394: uint32_t src; ! 395: uint32_t dst; ! 396: uint32_t res; ! 397: uint32_t flags = 0; ! 398: /* were gonna have to redo the muls. */ ! 399: int64_t tmp, t0 ,t1; ! 400: int32_t mof; ! 401: int dneg; ! 402: ! 403: src = env->cc_src; ! 404: dst = env->cc_dest; ! 405: res = env->cc_result; ! 406: ! 407: ! 408: /* cast into signed values to make GCC sign extend. */ ! 409: t0 = (int32_t)src; ! 410: t1 = (int32_t)dst; ! 411: dneg = ((int32_t)res) < 0; ! 412: ! 413: tmp = t0 * t1; ! 414: mof = tmp >> 32; ! 415: if (tmp == 0) ! 416: flags |= Z_FLAG; ! 417: else if (tmp < 0) ! 418: flags |= N_FLAG; ! 419: if ((dneg && mof != -1) ! 420: || (!dneg && mof != 0)) ! 421: flags |= V_FLAG; ! 422: evaluate_flags_writeback(flags); ! 423: RETURN(); ! 424: } ! 425: ! 426: void OPPROTO op_evaluate_flags_mulu(void) ! 427: { ! 428: uint32_t src; ! 429: uint32_t dst; ! 430: uint32_t res; ! 431: uint32_t flags = 0; ! 432: /* were gonna have to redo the muls. */ ! 433: uint64_t tmp, t0 ,t1; ! 434: uint32_t mof; ! 435: ! 436: src = env->cc_src; ! 437: dst = env->cc_dest; ! 438: res = env->cc_result; ! 439: ! 440: ! 441: /* cast into signed values to make GCC sign extend. */ ! 442: t0 = src; ! 443: t1 = dst; ! 444: ! 445: tmp = t0 * t1; ! 446: mof = tmp >> 32; ! 447: if (tmp == 0) ! 448: flags |= Z_FLAG; ! 449: else if (tmp >> 63) ! 450: flags |= N_FLAG; ! 451: if (mof) ! 452: flags |= V_FLAG; ! 453: ! 454: evaluate_flags_writeback(flags); ! 455: RETURN(); ! 456: } ! 457: ! 458: void OPPROTO op_evaluate_flags_mcp(void) ! 459: { ! 460: uint32_t src; ! 461: uint32_t dst; ! 462: uint32_t res; ! 463: uint32_t flags = 0; ! 464: ! 465: src = env->cc_src; ! 466: dst = env->cc_dest; ! 467: res = env->cc_result; ! 468: ! 469: if ((res & 0x80000000L) != 0L) ! 470: { ! 471: flags |= N_FLAG; ! 472: if (((src & 0x80000000L) == 0L) ! 473: && ((dst & 0x80000000L) == 0L)) ! 474: { ! 475: flags |= V_FLAG; ! 476: } ! 477: else if (((src & 0x80000000L) != 0L) && ! 478: ((dst & 0x80000000L) != 0L)) ! 479: { ! 480: flags |= R_FLAG; ! 481: } ! 482: } ! 483: else ! 484: { ! 485: if (res == 0L) ! 486: flags |= Z_FLAG; ! 487: if (((src & 0x80000000L) != 0L) ! 488: && ((dst & 0x80000000L) != 0L)) ! 489: flags |= V_FLAG; ! 490: if ((dst & 0x80000000L) != 0L ! 491: || (src & 0x80000000L) != 0L) ! 492: flags |= R_FLAG; ! 493: } ! 494: ! 495: evaluate_flags_writeback(flags); ! 496: RETURN(); ! 497: } ! 498: ! 499: void OPPROTO op_evaluate_flags_alu_4(void) ! 500: { ! 501: uint32_t src; ! 502: uint32_t dst; ! 503: uint32_t res; ! 504: uint32_t flags = 0; ! 505: ! 506: src = env->cc_src; ! 507: dst = env->cc_dest; ! 508: res = env->cc_result; ! 509: ! 510: if ((res & 0x80000000L) != 0L) ! 511: { ! 512: flags |= N_FLAG; ! 513: if (((src & 0x80000000L) == 0L) ! 514: && ((dst & 0x80000000L) == 0L)) ! 515: { ! 516: flags |= V_FLAG; ! 517: } ! 518: else if (((src & 0x80000000L) != 0L) && ! 519: ((dst & 0x80000000L) != 0L)) ! 520: { ! 521: flags |= C_FLAG; ! 522: } ! 523: } ! 524: else ! 525: { ! 526: if (res == 0L) ! 527: flags |= Z_FLAG; ! 528: if (((src & 0x80000000L) != 0L) ! 529: && ((dst & 0x80000000L) != 0L)) ! 530: flags |= V_FLAG; ! 531: if ((dst & 0x80000000L) != 0L ! 532: || (src & 0x80000000L) != 0L) ! 533: flags |= C_FLAG; ! 534: } ! 535: ! 536: if (env->cc_op == CC_OP_SUB ! 537: || env->cc_op == CC_OP_CMP) { ! 538: flags ^= C_FLAG; ! 539: } ! 540: evaluate_flags_writeback(flags); ! 541: RETURN(); ! 542: } ! 543: ! 544: void OPPROTO op_evaluate_flags_move_4 (void) ! 545: { ! 546: uint32_t src; ! 547: uint32_t res; ! 548: uint32_t flags = 0; ! 549: ! 550: src = env->cc_src; ! 551: res = env->cc_result; ! 552: ! 553: if ((int32_t)res < 0) ! 554: flags |= N_FLAG; ! 555: else if (res == 0L) ! 556: flags |= Z_FLAG; ! 557: ! 558: evaluate_flags_writeback(flags); ! 559: RETURN(); ! 560: } ! 561: void OPPROTO op_evaluate_flags_move_2 (void) ! 562: { ! 563: uint32_t src; ! 564: uint32_t flags = 0; ! 565: uint16_t res; ! 566: ! 567: src = env->cc_src; ! 568: res = env->cc_result; ! 569: ! 570: if ((int16_t)res < 0L) ! 571: flags |= N_FLAG; ! 572: else if (res == 0) ! 573: flags |= Z_FLAG; ! 574: ! 575: evaluate_flags_writeback(flags); ! 576: RETURN(); ! 577: } ! 578: ! 579: /* TODO: This is expensive. We could split things up and only evaluate part of ! 580: CCR on a need to know basis. For now, we simply re-evaluate everything. */ ! 581: void OPPROTO op_evaluate_flags (void) ! 582: { ! 583: uint32_t src; ! 584: uint32_t dst; ! 585: uint32_t res; ! 586: uint32_t flags = 0; ! 587: ! 588: src = env->cc_src; ! 589: dst = env->cc_dest; ! 590: res = env->cc_result; ! 591: ! 592: ! 593: /* Now, evaluate the flags. This stuff is based on ! 594: Per Zander's CRISv10 simulator. */ ! 595: switch (env->cc_size) ! 596: { ! 597: case 1: ! 598: if ((res & 0x80L) != 0L) ! 599: { ! 600: flags |= N_FLAG; ! 601: if (((src & 0x80L) == 0L) ! 602: && ((dst & 0x80L) == 0L)) ! 603: { ! 604: flags |= V_FLAG; ! 605: } ! 606: else if (((src & 0x80L) != 0L) ! 607: && ((dst & 0x80L) != 0L)) ! 608: { ! 609: flags |= C_FLAG; ! 610: } ! 611: } ! 612: else ! 613: { ! 614: if ((res & 0xFFL) == 0L) ! 615: { ! 616: flags |= Z_FLAG; ! 617: } ! 618: if (((src & 0x80L) != 0L) ! 619: && ((dst & 0x80L) != 0L)) ! 620: { ! 621: flags |= V_FLAG; ! 622: } ! 623: if ((dst & 0x80L) != 0L ! 624: || (src & 0x80L) != 0L) ! 625: { ! 626: flags |= C_FLAG; ! 627: } ! 628: } ! 629: break; ! 630: case 2: ! 631: if ((res & 0x8000L) != 0L) ! 632: { ! 633: flags |= N_FLAG; ! 634: if (((src & 0x8000L) == 0L) ! 635: && ((dst & 0x8000L) == 0L)) ! 636: { ! 637: flags |= V_FLAG; ! 638: } ! 639: else if (((src & 0x8000L) != 0L) ! 640: && ((dst & 0x8000L) != 0L)) ! 641: { ! 642: flags |= C_FLAG; ! 643: } ! 644: } ! 645: else ! 646: { ! 647: if ((res & 0xFFFFL) == 0L) ! 648: { ! 649: flags |= Z_FLAG; ! 650: } ! 651: if (((src & 0x8000L) != 0L) ! 652: && ((dst & 0x8000L) != 0L)) ! 653: { ! 654: flags |= V_FLAG; ! 655: } ! 656: if ((dst & 0x8000L) != 0L ! 657: || (src & 0x8000L) != 0L) ! 658: { ! 659: flags |= C_FLAG; ! 660: } ! 661: } ! 662: break; ! 663: case 4: ! 664: if ((res & 0x80000000L) != 0L) ! 665: { ! 666: flags |= N_FLAG; ! 667: if (((src & 0x80000000L) == 0L) ! 668: && ((dst & 0x80000000L) == 0L)) ! 669: { ! 670: flags |= V_FLAG; ! 671: } ! 672: else if (((src & 0x80000000L) != 0L) && ! 673: ((dst & 0x80000000L) != 0L)) ! 674: { ! 675: flags |= C_FLAG; ! 676: } ! 677: } ! 678: else ! 679: { ! 680: if (res == 0L) ! 681: flags |= Z_FLAG; ! 682: if (((src & 0x80000000L) != 0L) ! 683: && ((dst & 0x80000000L) != 0L)) ! 684: flags |= V_FLAG; ! 685: if ((dst & 0x80000000L) != 0L ! 686: || (src & 0x80000000L) != 0L) ! 687: flags |= C_FLAG; ! 688: } ! 689: break; ! 690: default: ! 691: break; ! 692: } ! 693: ! 694: if (env->cc_op == CC_OP_SUB ! 695: || env->cc_op == CC_OP_CMP) { ! 696: flags ^= C_FLAG; ! 697: } ! 698: evaluate_flags_writeback(flags); ! 699: RETURN(); ! 700: } ! 701: ! 702: void OPPROTO op_extb_T0_T0 (void) ! 703: { ! 704: T0 = ((int8_t)T0); ! 705: RETURN(); ! 706: } ! 707: void OPPROTO op_extb_T1_T0 (void) ! 708: { ! 709: T1 = ((int8_t)T0); ! 710: RETURN(); ! 711: } ! 712: void OPPROTO op_extb_T1_T1 (void) ! 713: { ! 714: T1 = ((int8_t)T1); ! 715: RETURN(); ! 716: } ! 717: void OPPROTO op_zextb_T0_T0 (void) ! 718: { ! 719: T0 = ((uint8_t)T0); ! 720: RETURN(); ! 721: } ! 722: void OPPROTO op_zextb_T1_T0 (void) ! 723: { ! 724: T1 = ((uint8_t)T0); ! 725: RETURN(); ! 726: } ! 727: void OPPROTO op_zextb_T1_T1 (void) ! 728: { ! 729: T1 = ((uint8_t)T1); ! 730: RETURN(); ! 731: } ! 732: void OPPROTO op_extw_T0_T0 (void) ! 733: { ! 734: T0 = ((int16_t)T0); ! 735: RETURN(); ! 736: } ! 737: void OPPROTO op_extw_T1_T0 (void) ! 738: { ! 739: T1 = ((int16_t)T0); ! 740: RETURN(); ! 741: } ! 742: void OPPROTO op_extw_T1_T1 (void) ! 743: { ! 744: T1 = ((int16_t)T1); ! 745: RETURN(); ! 746: } ! 747: ! 748: void OPPROTO op_zextw_T0_T0 (void) ! 749: { ! 750: T0 = ((uint16_t)T0); ! 751: RETURN(); ! 752: } ! 753: void OPPROTO op_zextw_T1_T0 (void) ! 754: { ! 755: T1 = ((uint16_t)T0); ! 756: RETURN(); ! 757: } ! 758: ! 759: void OPPROTO op_zextw_T1_T1 (void) ! 760: { ! 761: T1 = ((uint16_t)T1); ! 762: RETURN(); ! 763: } ! 764: ! 765: void OPPROTO op_movl_T0_im (void) ! 766: { ! 767: T0 = PARAM1; ! 768: RETURN(); ! 769: } ! 770: void OPPROTO op_movl_T1_im (void) ! 771: { ! 772: T1 = PARAM1; ! 773: RETURN(); ! 774: } ! 775: ! 776: void OPPROTO op_addl_T0_im (void) ! 777: { ! 778: T0 += PARAM1; ! 779: RETURN(); ! 780: } ! 781: ! 782: void OPPROTO op_addl_T1_im (void) ! 783: { ! 784: T1 += PARAM1; ! 785: RETURN(); ! 786: ! 787: } ! 788: void OPPROTO op_subl_T0_im (void) ! 789: { ! 790: T0 -= PARAM1; ! 791: RETURN(); ! 792: } ! 793: ! 794: void OPPROTO op_addxl_T0_C (void) ! 795: { ! 796: if (env->pregs[SR_CCS] & X_FLAG) ! 797: T0 += !!(env->pregs[SR_CCS] & C_FLAG); ! 798: RETURN(); ! 799: } ! 800: void OPPROTO op_subxl_T0_C (void) ! 801: { ! 802: if (env->pregs[SR_CCS] & X_FLAG) ! 803: T0 -= !!(env->pregs[SR_CCS] & C_FLAG); ! 804: RETURN(); ! 805: } ! 806: void OPPROTO op_addl_T0_C (void) ! 807: { ! 808: T0 += !!(env->pregs[SR_CCS] & C_FLAG); ! 809: RETURN(); ! 810: } ! 811: void OPPROTO op_addl_T0_R (void) ! 812: { ! 813: T0 += !!(env->pregs[SR_CCS] & R_FLAG); ! 814: RETURN(); ! 815: } ! 816: ! 817: void OPPROTO op_clr_R (void) ! 818: { ! 819: env->pregs[SR_CCS] &= ~R_FLAG; ! 820: RETURN(); ! 821: } ! 822: ! 823: ! 824: void OPPROTO op_andl_T0_im (void) ! 825: { ! 826: T0 &= PARAM1; ! 827: RETURN(); ! 828: } ! 829: ! 830: void OPPROTO op_andl_T1_im (void) ! 831: { ! 832: T1 &= PARAM1; ! 833: RETURN(); ! 834: } ! 835: ! 836: void OPPROTO op_movl_T0_T1 (void) ! 837: { ! 838: T0 = T1; ! 839: RETURN(); ! 840: } ! 841: ! 842: void OPPROTO op_swp_T0_T1 (void) ! 843: { ! 844: T0 ^= T1; ! 845: T1 ^= T0; ! 846: T0 ^= T1; ! 847: RETURN(); ! 848: } ! 849: ! 850: void OPPROTO op_movl_T1_T0 (void) ! 851: { ! 852: T1 = T0; ! 853: RETURN(); ! 854: } ! 855: ! 856: void OPPROTO op_movl_pc_T0 (void) ! 857: { ! 858: env->pc = T0; ! 859: RETURN(); ! 860: } ! 861: ! 862: void OPPROTO op_movl_T0_0 (void) ! 863: { ! 864: T0 = 0; ! 865: RETURN(); ! 866: } ! 867: ! 868: void OPPROTO op_addl_T0_T1 (void) ! 869: { ! 870: T0 += T1; ! 871: RETURN(); ! 872: } ! 873: ! 874: void OPPROTO op_subl_T0_T1 (void) ! 875: { ! 876: T0 -= T1; ! 877: RETURN(); ! 878: } ! 879: ! 880: void OPPROTO op_absl_T1_T1 (void) ! 881: { ! 882: int32_t st = T1; ! 883: ! 884: T1 = st < 0 ? -st : st; ! 885: RETURN(); ! 886: } ! 887: ! 888: void OPPROTO op_muls_T0_T1 (void) ! 889: { ! 890: int64_t tmp, t0 ,t1; ! 891: ! 892: /* cast into signed values to make GCC sign extend these babies. */ ! 893: t0 = (int32_t)T0; ! 894: t1 = (int32_t)T1; ! 895: ! 896: tmp = t0 * t1; ! 897: T0 = tmp & 0xffffffff; ! 898: env->pregs[REG_MOF] = tmp >> 32; ! 899: RETURN(); ! 900: } ! 901: ! 902: void OPPROTO op_mulu_T0_T1 (void) ! 903: { ! 904: uint64_t tmp, t0 ,t1; ! 905: t0 = T0; ! 906: t1 = T1; ! 907: ! 908: tmp = t0 * t1; ! 909: T0 = tmp & 0xffffffff; ! 910: env->pregs[REG_MOF] = tmp >> 32; ! 911: RETURN(); ! 912: } ! 913: ! 914: void OPPROTO op_dstep_T0_T1 (void) ! 915: { ! 916: T0 <<= 1; ! 917: if (T0 >= T1) ! 918: T0 -= T1; ! 919: RETURN(); ! 920: } ! 921: ! 922: void OPPROTO op_orl_T0_T1 (void) ! 923: { ! 924: T0 |= T1; ! 925: RETURN(); ! 926: } ! 927: ! 928: void OPPROTO op_andl_T0_T1 (void) ! 929: { ! 930: T0 &= T1; ! 931: RETURN(); ! 932: } ! 933: ! 934: void OPPROTO op_xorl_T0_T1 (void) ! 935: { ! 936: T0 ^= T1; ! 937: RETURN(); ! 938: } ! 939: ! 940: void OPPROTO op_lsll_T0_T1 (void) ! 941: { ! 942: int s = T1; ! 943: if (s > 31) ! 944: T0 = 0; ! 945: else ! 946: T0 <<= s; ! 947: RETURN(); ! 948: } ! 949: ! 950: void OPPROTO op_lsll_T0_im (void) ! 951: { ! 952: T0 <<= PARAM1; ! 953: RETURN(); ! 954: } ! 955: ! 956: void OPPROTO op_lsrl_T0_T1 (void) ! 957: { ! 958: int s = T1; ! 959: if (s > 31) ! 960: T0 = 0; ! 961: else ! 962: T0 >>= s; ! 963: RETURN(); ! 964: } ! 965: ! 966: /* Rely on GCC emitting an arithmetic shift for signed right shifts. */ ! 967: void OPPROTO op_asrl_T0_T1 (void) ! 968: { ! 969: int s = T1; ! 970: if (s > 31) ! 971: T0 = T0 & 0x80000000 ? -1 : 0; ! 972: else ! 973: T0 = (int32_t)T0 >> s; ! 974: RETURN(); ! 975: } ! 976: ! 977: void OPPROTO op_btst_T0_T1 (void) ! 978: { ! 979: /* FIXME: clean this up. */ ! 980: ! 981: /* des ref: ! 982: The N flag is set according to the selected bit in the dest reg. ! 983: The Z flag is set if the selected bit and all bits to the right are ! 984: zero. ! 985: The destination reg is not affected.*/ ! 986: unsigned int fz, sbit, bset, mask, masked_t0; ! 987: ! 988: sbit = T1 & 31; ! 989: bset = !!(T0 & (1 << sbit)); ! 990: mask = sbit == 31 ? -1 : (1 << (sbit + 1)) - 1; ! 991: masked_t0 = T0 & mask; ! 992: fz = !(masked_t0 | bset); ! 993: /* Set the N and Z flags accordingly. */ ! 994: T0 = (bset << 3) | (fz << 2); ! 995: RETURN(); ! 996: } ! 997: ! 998: void OPPROTO op_bound_T0_T1 (void) ! 999: { ! 1000: if (T0 > T1) ! 1001: T0 = T1; ! 1002: RETURN(); ! 1003: } ! 1004: ! 1005: void OPPROTO op_lz_T0_T1 (void) ! 1006: { ! 1007: T0 = clz32(T1); ! 1008: RETURN(); ! 1009: } ! 1010: ! 1011: void OPPROTO op_negl_T0_T1 (void) ! 1012: { ! 1013: T0 = -T1; ! 1014: RETURN(); ! 1015: } ! 1016: ! 1017: void OPPROTO op_negl_T1_T1 (void) ! 1018: { ! 1019: T1 = -T1; ! 1020: RETURN(); ! 1021: } ! 1022: ! 1023: void OPPROTO op_not_T0_T0 (void) ! 1024: { ! 1025: T0 = ~(T0); ! 1026: RETURN(); ! 1027: } ! 1028: void OPPROTO op_not_T1_T1 (void) ! 1029: { ! 1030: T1 = ~(T1); ! 1031: RETURN(); ! 1032: } ! 1033: ! 1034: void OPPROTO op_swapw_T0_T0 (void) ! 1035: { ! 1036: T0 = (T0 << 16) | ((T0 >> 16)); ! 1037: RETURN(); ! 1038: } ! 1039: ! 1040: void OPPROTO op_swapb_T0_T0 (void) ! 1041: { ! 1042: T0 = ((T0 << 8) & 0xff00ff00) | ((T0 >> 8) & 0x00ff00ff); ! 1043: RETURN(); ! 1044: } ! 1045: ! 1046: void OPPROTO op_swapr_T0_T0 (void) ! 1047: { ! 1048: T0 = (((T0 << 7) & 0x80808080) | ! 1049: ((T0 << 5) & 0x40404040) | ! 1050: ((T0 << 3) & 0x20202020) | ! 1051: ((T0 << 1) & 0x10101010) | ! 1052: ((T0 >> 1) & 0x08080808) | ! 1053: ((T0 >> 3) & 0x04040404) | ! 1054: ((T0 >> 5) & 0x02020202) | ! 1055: ((T0 >> 7) & 0x01010101)); ! 1056: RETURN(); ! 1057: } ! 1058: ! 1059: void OPPROTO op_tst_cc_eq (void) { ! 1060: uint32_t flags = env->pregs[SR_CCS]; ! 1061: int z_set; ! 1062: ! 1063: z_set = !!(flags & Z_FLAG); ! 1064: T0 = z_set; ! 1065: RETURN(); ! 1066: } ! 1067: ! 1068: void OPPROTO op_tst_cc_eq_fast (void) { ! 1069: T0 = !(env->cc_result); ! 1070: RETURN(); ! 1071: } ! 1072: ! 1073: void OPPROTO op_tst_cc_ne (void) { ! 1074: uint32_t flags = env->pregs[SR_CCS]; ! 1075: int z_set; ! 1076: ! 1077: z_set = !!(flags & Z_FLAG); ! 1078: T0 = !z_set; ! 1079: RETURN(); ! 1080: } ! 1081: void OPPROTO op_tst_cc_ne_fast (void) { ! 1082: T0 = !!(env->cc_result); ! 1083: RETURN(); ! 1084: } ! 1085: ! 1086: void OPPROTO op_tst_cc_cc (void) { ! 1087: uint32_t flags = env->pregs[SR_CCS]; ! 1088: int c_set; ! 1089: ! 1090: c_set = !!(flags & C_FLAG); ! 1091: T0 = !c_set; ! 1092: RETURN(); ! 1093: } ! 1094: void OPPROTO op_tst_cc_cs (void) { ! 1095: uint32_t flags = env->pregs[SR_CCS]; ! 1096: int c_set; ! 1097: ! 1098: c_set = !!(flags & C_FLAG); ! 1099: T0 = c_set; ! 1100: RETURN(); ! 1101: } ! 1102: ! 1103: void OPPROTO op_tst_cc_vc (void) { ! 1104: uint32_t flags = env->pregs[SR_CCS]; ! 1105: int v_set; ! 1106: ! 1107: v_set = !!(flags & V_FLAG); ! 1108: T0 = !v_set; ! 1109: RETURN(); ! 1110: } ! 1111: void OPPROTO op_tst_cc_vs (void) { ! 1112: uint32_t flags = env->pregs[SR_CCS]; ! 1113: int v_set; ! 1114: ! 1115: v_set = !!(flags & V_FLAG); ! 1116: T0 = v_set; ! 1117: RETURN(); ! 1118: } ! 1119: void OPPROTO op_tst_cc_pl (void) { ! 1120: uint32_t flags = env->pregs[SR_CCS]; ! 1121: int n_set; ! 1122: ! 1123: n_set = !!(flags & N_FLAG); ! 1124: T0 = !n_set; ! 1125: RETURN(); ! 1126: } ! 1127: void OPPROTO op_tst_cc_pl_fast (void) { ! 1128: T0 = ((int32_t)env->cc_result) >= 0; ! 1129: RETURN(); ! 1130: } ! 1131: ! 1132: void OPPROTO op_tst_cc_mi (void) { ! 1133: uint32_t flags = env->pregs[SR_CCS]; ! 1134: int n_set; ! 1135: ! 1136: n_set = !!(flags & N_FLAG); ! 1137: T0 = n_set; ! 1138: RETURN(); ! 1139: } ! 1140: void OPPROTO op_tst_cc_mi_fast (void) { ! 1141: T0 = ((int32_t)env->cc_result) < 0; ! 1142: RETURN(); ! 1143: } ! 1144: ! 1145: void OPPROTO op_tst_cc_ls (void) { ! 1146: uint32_t flags = env->pregs[SR_CCS]; ! 1147: int c_set; ! 1148: int z_set; ! 1149: ! 1150: c_set = !!(flags & C_FLAG); ! 1151: z_set = !!(flags & Z_FLAG); ! 1152: T0 = c_set || z_set; ! 1153: RETURN(); ! 1154: } ! 1155: void OPPROTO op_tst_cc_hi (void) { ! 1156: uint32_t flags = env->pregs[SR_CCS]; ! 1157: int z_set; ! 1158: int c_set; ! 1159: ! 1160: z_set = !!(flags & Z_FLAG); ! 1161: c_set = !!(flags & C_FLAG); ! 1162: T0 = !c_set && !z_set; ! 1163: RETURN(); ! 1164: ! 1165: } ! 1166: ! 1167: void OPPROTO op_tst_cc_ge (void) { ! 1168: uint32_t flags = env->pregs[SR_CCS]; ! 1169: int n_set; ! 1170: int v_set; ! 1171: ! 1172: n_set = !!(flags & N_FLAG); ! 1173: v_set = !!(flags & V_FLAG); ! 1174: T0 = (n_set && v_set) || (!n_set && !v_set); ! 1175: RETURN(); ! 1176: } ! 1177: ! 1178: void OPPROTO op_tst_cc_ge_fast (void) { ! 1179: T0 = ((int32_t)env->cc_src < (int32_t)env->cc_dest); ! 1180: RETURN(); ! 1181: } ! 1182: ! 1183: void OPPROTO op_tst_cc_lt (void) { ! 1184: uint32_t flags = env->pregs[SR_CCS]; ! 1185: int n_set; ! 1186: int v_set; ! 1187: ! 1188: n_set = !!(flags & N_FLAG); ! 1189: v_set = !!(flags & V_FLAG); ! 1190: T0 = (n_set && !v_set) || (!n_set && v_set); ! 1191: RETURN(); ! 1192: } ! 1193: ! 1194: void OPPROTO op_tst_cc_gt (void) { ! 1195: uint32_t flags = env->pregs[SR_CCS]; ! 1196: int n_set; ! 1197: int v_set; ! 1198: int z_set; ! 1199: ! 1200: n_set = !!(flags & N_FLAG); ! 1201: v_set = !!(flags & V_FLAG); ! 1202: z_set = !!(flags & Z_FLAG); ! 1203: T0 = (n_set && v_set && !z_set) ! 1204: || (!n_set && !v_set && !z_set); ! 1205: RETURN(); ! 1206: } ! 1207: ! 1208: void OPPROTO op_tst_cc_le (void) { ! 1209: uint32_t flags = env->pregs[SR_CCS]; ! 1210: int n_set; ! 1211: int v_set; ! 1212: int z_set; ! 1213: ! 1214: n_set = !!(flags & N_FLAG); ! 1215: v_set = !!(flags & V_FLAG); ! 1216: z_set = !!(flags & Z_FLAG); ! 1217: T0 = z_set || (n_set && !v_set) || (!n_set && v_set); ! 1218: RETURN(); ! 1219: } ! 1220: ! 1221: void OPPROTO op_tst_cc_p (void) { ! 1222: uint32_t flags = env->pregs[SR_CCS]; ! 1223: int p_set; ! 1224: ! 1225: p_set = !!(flags & P_FLAG); ! 1226: T0 = p_set; ! 1227: RETURN(); ! 1228: } ! 1229: ! 1230: /* Evaluate the if the branch should be taken or not. Needs to be done in ! 1231: the original sequence. The acutal branch is rescheduled to right after the ! 1232: delay-slot. */ ! 1233: void OPPROTO op_evaluate_bcc (void) ! 1234: { ! 1235: env->btaken = T0; ! 1236: RETURN(); ! 1237: } ! 1238: ! 1239: /* this one is used on every alu op, optimize it!. */ ! 1240: void OPPROTO op_goto_if_not_x (void) ! 1241: { ! 1242: if (env->pregs[SR_CCS] & X_FLAG) ! 1243: GOTO_LABEL_PARAM(1); ! 1244: RETURN(); ! 1245: } ! 1246: ! 1247: void OPPROTO op_cc_jmp (void) ! 1248: { ! 1249: if (env->btaken) ! 1250: env->pc = PARAM1; ! 1251: else ! 1252: env->pc = PARAM2; ! 1253: RETURN(); ! 1254: } ! 1255: ! 1256: void OPPROTO op_cc_ngoto (void) ! 1257: { ! 1258: if (!env->btaken) ! 1259: GOTO_LABEL_PARAM(1); ! 1260: RETURN(); ! 1261: } ! 1262: ! 1263: void OPPROTO op_movl_btarget_T0 (void) ! 1264: { ! 1265: env->btarget = T0; ! 1266: RETURN(); ! 1267: } ! 1268: ! 1269: void OPPROTO op_jmp (void) ! 1270: { ! 1271: env->pc = env->btarget; ! 1272: RETURN(); ! 1273: } ! 1274: ! 1275: /* Load and store */ ! 1276: #define MEMSUFFIX _raw ! 1277: #include "op_mem.c" ! 1278: #undef MEMSUFFIX ! 1279: #if !defined(CONFIG_USER_ONLY) ! 1280: #define MEMSUFFIX _user ! 1281: #include "op_mem.c" ! 1282: #undef MEMSUFFIX ! 1283: ! 1284: #define MEMSUFFIX _kernel ! 1285: #include "op_mem.c" ! 1286: #undef MEMSUFFIX ! 1287: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.