src/emu/cpu/rsp/rspdrc.c
| r14545 | r14546 | |
| 124 | 124 | UINT32 vres[8]; /* used for temporary vector results */ |
| 125 | 125 | |
| 126 | 126 | /* register mappings */ |
| 127 | | parameter regmap[32]; /* parameter to register mappings for all 32 integer registers */ |
| 127 | parameter regmap[34]; /* parameter to register mappings for all 32 integer registers */ |
| 128 | 128 | |
| 129 | 129 | /* subroutines */ |
| 130 | 130 | code_handle * entry; /* entry point */ |
| r14545 | r14546 | |
| 210 | 210 | #define VS2REG ((op >> 16) & 0x1f) |
| 211 | 211 | #define EL ((op >> 21) & 0xf) |
| 212 | 212 | |
| 213 | | #define VREG_B(reg, offset) rsp->v[(reg)].b[BYTE4_XOR_BE(offset)] |
| 214 | | #define VREG_S(reg, offset) rsp->v[(reg)].s[(offset)^1] |
| 213 | #define VREG_B(reg, offset) rsp->v[(reg)].b[(offset)^1] |
| 214 | #define W_VREG_S(reg, offset) rsp->v[(reg)].s[(offset)] |
| 215 | #define VREG_S(reg, offset) (INT16)rsp->v[(reg)].s[(offset)] |
| 215 | 216 | |
| 216 | 217 | #define VEC_EL_2(x,z) (vector_elements_2[(x)][(z)]) |
| 217 | 218 | |
| r14545 | r14546 | |
| 320 | 321 | |
| 321 | 322 | INLINE UINT8 READ8(rsp_state *rsp, UINT32 address) |
| 322 | 323 | { |
| 323 | | return rsp->dmem8[BYTE4_XOR_BE(address & 0xfff)]; |
| 324 | UINT8 ret = rsp->dmem8[BYTE4_XOR_BE(address & 0xfff)]; |
| 325 | //printf("%04xr%02x\n",address, ret); |
| 326 | return ret; |
| 324 | 327 | } |
| 325 | 328 | |
| 326 | 329 | static void cfunc_read8(void *param) |
| r14545 | r14546 | |
| 367 | 370 | { |
| 368 | 371 | address &= 0xfff; |
| 369 | 372 | rsp->dmem8[BYTE4_XOR_BE(address)] = data; |
| 370 | | //printf("%04xw%02x\n",address, data); |
| 373 | //printf("%04x:%02x\n",address, data); |
| 371 | 374 | } |
| 372 | 375 | |
| 373 | 376 | static void cfunc_write8(void *param) |
| r14545 | r14546 | |
| 381 | 384 | address &= 0xfff; |
| 382 | 385 | rsp->dmem8[BYTE4_XOR_BE(address)] = data >> 8; |
| 383 | 386 | rsp->dmem8[BYTE4_XOR_BE(address + 1)] = data & 0xff; |
| 384 | | //printf("%04xw%04x\n",address, data); |
| 387 | //printf("%04x:%04x\n",address, data); |
| 385 | 388 | } |
| 386 | 389 | |
| 387 | 390 | static void cfunc_write16(void *param) |
| r14545 | r14546 | |
| 397 | 400 | rsp->dmem8[BYTE4_XOR_BE(address + 1)] = (data >> 16) & 0xff; |
| 398 | 401 | rsp->dmem8[BYTE4_XOR_BE(address + 2)] = (data >> 8) & 0xff; |
| 399 | 402 | rsp->dmem8[BYTE4_XOR_BE(address + 3)] = data & 0xff; |
| 400 | | //printf("%04xw%08x\n",address, data); |
| 403 | //printf("%04x:%08x\n",address, data); |
| 401 | 404 | } |
| 402 | 405 | |
| 403 | 406 | static void cfunc_write32(void *param) |
| r14545 | r14546 | |
| 431 | 434 | switch(rsp->impstate->arg2) |
| 432 | 435 | { |
| 433 | 436 | case 0: // WRITE8 |
| 434 | | printf("%04x:%02x\n", rsp->impstate->arg0 & 0x0fff, (UINT8)rsp->impstate->arg1); |
| 437 | printf("%04x:%02x\n", rsp->impstate->arg0 & 0xffff, (UINT8)rsp->impstate->arg1); |
| 435 | 438 | break; |
| 436 | 439 | case 1: // WRITE16 |
| 437 | | printf("%04x:%04x\n", rsp->impstate->arg0 & 0x0fff, (UINT16)rsp->impstate->arg1); |
| 440 | printf("%04x:%04x\n", rsp->impstate->arg0 & 0xffff, (UINT16)rsp->impstate->arg1); |
| 438 | 441 | break; |
| 439 | 442 | case 2: // WRITE32 |
| 440 | | printf("%04x:%08x\n", rsp->impstate->arg0 & 0x0fff, rsp->impstate->arg1); |
| 443 | printf("%04x:%08x\n", rsp->impstate->arg0 & 0xffff, rsp->impstate->arg1); |
| 441 | 444 | break; |
| 442 | 445 | case 3: // READ8 |
| 443 | | printf("%04xr%02x\n", rsp->impstate->arg0 & 0x0fff, (UINT8)rsp->impstate->arg1); |
| 446 | printf("%04xr%02x\n", rsp->impstate->arg0 & 0xffff, (UINT8)rsp->impstate->arg1); |
| 444 | 447 | break; |
| 445 | 448 | case 4: // READ16 |
| 446 | | printf("%04xr%04x\n", rsp->impstate->arg0 & 0x0fff, (UINT16)rsp->impstate->arg1); |
| 449 | printf("%04xr%04x\n", rsp->impstate->arg0 & 0xffff, (UINT16)rsp->impstate->arg1); |
| 447 | 450 | break; |
| 448 | 451 | case 5: // READ32 |
| 449 | | printf("%04xr%08x\n", rsp->impstate->arg0 & 0x0fff, rsp->impstate->arg1); |
| 452 | printf("%04xr%08x\n", rsp->impstate->arg0 & 0xffff, rsp->impstate->arg1); |
| 450 | 453 | break; |
| 454 | case 6: // Checksum |
| 455 | printf("Sum: %08x\n", rsp->impstate->arg0); |
| 456 | break; |
| 457 | case 7: // Checksum |
| 458 | printf("Correct Sum: %08x\n", rsp->impstate->arg0); |
| 459 | break; |
| 451 | 460 | default: // ??? |
| 452 | | printf("%08x %08x\n", rsp->impstate->arg0 & 0x0fff, rsp->impstate->arg1); |
| 461 | printf("%08x %08x\n", rsp->impstate->arg0 & 0xffff, rsp->impstate->arg1); |
| 453 | 462 | break; |
| 454 | 463 | } |
| 455 | 464 | } |
| r14545 | r14546 | |
| 860 | 869 | |
| 861 | 870 | end = index + (16 - (ea & 0xf)); |
| 862 | 871 | if (end > 16) end = 16; |
| 872 | |
| 863 | 873 | for (i=index; i < end; i++) |
| 864 | 874 | { |
| 865 | 875 | VREG_B(dest, i) = READ8(rsp, ea); |
| r14545 | r14546 | |
| 927 | 937 | |
| 928 | 938 | for (i=0; i < 8; i++) |
| 929 | 939 | { |
| 930 | | VREG_S(dest, i) = READ8(rsp, ea + (((16-index) + i) & 0xf)) << 8; |
| 940 | W_VREG_S(dest, i) = READ8(rsp, ea + (((16-index) + i) & 0xf)) << 8; |
| 931 | 941 | } |
| 932 | 942 | } |
| 933 | 943 | |
| r14545 | r14546 | |
| 956 | 966 | |
| 957 | 967 | for (i=0; i < 8; i++) |
| 958 | 968 | { |
| 959 | | VREG_S(dest, i) = READ8(rsp, ea + (((16-index) + i) & 0xf)) << 7; |
| 969 | W_VREG_S(dest, i) = READ8(rsp, ea + (((16-index) + i) & 0xf)) << 7; |
| 960 | 970 | } |
| 961 | 971 | } |
| 962 | 972 | |
| r14545 | r14546 | |
| 985 | 995 | |
| 986 | 996 | for (i=0; i < 8; i++) |
| 987 | 997 | { |
| 988 | | VREG_S(dest, i) = READ8(rsp, ea + (((16-index) + (i<<1)) & 0xf)) << 7; |
| 998 | W_VREG_S(dest, i) = READ8(rsp, ea + (((16-index) + (i<<1)) & 0xf)) << 7; |
| 989 | 999 | } |
| 990 | 1000 | } |
| 991 | 1001 | |
| r14545 | r14546 | |
| 1020 | 1030 | |
| 1021 | 1031 | for (i=index >> 1; i < end; i++) |
| 1022 | 1032 | { |
| 1023 | | VREG_S(dest, i) = READ8(rsp, ea) << 7; |
| 1033 | W_VREG_S(dest, i) = READ8(rsp, ea) << 7; |
| 1024 | 1034 | ea += 4; |
| 1025 | 1035 | } |
| 1026 | 1036 | } |
| r14545 | r14546 | |
| 1761 | 1771 | } |
| 1762 | 1772 | |
| 1763 | 1773 | #define WRITEBACK_RESULT() { \ |
| 1764 | | VREG_S(VDREG, 0) = vres[0]; \ |
| 1765 | | VREG_S(VDREG, 1) = vres[1]; \ |
| 1766 | | VREG_S(VDREG, 2) = vres[2]; \ |
| 1767 | | VREG_S(VDREG, 3) = vres[3]; \ |
| 1768 | | VREG_S(VDREG, 4) = vres[4]; \ |
| 1769 | | VREG_S(VDREG, 5) = vres[5]; \ |
| 1770 | | VREG_S(VDREG, 6) = vres[6]; \ |
| 1771 | | VREG_S(VDREG, 7) = vres[7]; \ |
| 1774 | W_VREG_S(VDREG, 0) = vres[0]; \ |
| 1775 | W_VREG_S(VDREG, 1) = vres[1]; \ |
| 1776 | W_VREG_S(VDREG, 2) = vres[2]; \ |
| 1777 | W_VREG_S(VDREG, 3) = vres[3]; \ |
| 1778 | W_VREG_S(VDREG, 4) = vres[4]; \ |
| 1779 | W_VREG_S(VDREG, 5) = vres[5]; \ |
| 1780 | W_VREG_S(VDREG, 6) = vres[6]; \ |
| 1781 | W_VREG_S(VDREG, 7) = vres[7]; \ |
| 1772 | 1782 | } |
| 1773 | 1783 | |
| 1774 | 1784 | INLINE void cfunc_rsp_vmulf(void *param) |
| r14545 | r14546 | |
| 2415 | 2425 | { |
| 2416 | 2426 | for (int i = 0; i < 8; i++) |
| 2417 | 2427 | { |
| 2418 | | VREG_S(VDREG, i) = ACCUM_H(i); |
| 2428 | W_VREG_S(VDREG, i) = ACCUM_H(i); |
| 2419 | 2429 | } |
| 2420 | 2430 | break; |
| 2421 | 2431 | } |
| r14545 | r14546 | |
| 2423 | 2433 | { |
| 2424 | 2434 | for (int i = 0; i < 8; i++) |
| 2425 | 2435 | { |
| 2426 | | VREG_S(VDREG, i) = ACCUM_M(i); |
| 2436 | W_VREG_S(VDREG, i) = ACCUM_M(i); |
| 2427 | 2437 | } |
| 2428 | 2438 | break; |
| 2429 | 2439 | } |
| r14545 | r14546 | |
| 2431 | 2441 | { |
| 2432 | 2442 | for (int i = 0; i < 8; i++) |
| 2433 | 2443 | { |
| 2434 | | VREG_S(VDREG, i) = ACCUM_L(i); |
| 2444 | W_VREG_S(VDREG, i) = ACCUM_L(i); |
| 2435 | 2445 | } |
| 2436 | 2446 | break; |
| 2437 | 2447 | } |
| r14545 | r14546 | |
| 3091 | 3101 | rsp->reciprocal_res = rec; |
| 3092 | 3102 | rsp->dp_allowed = 0; |
| 3093 | 3103 | |
| 3094 | | VREG_S(VDREG, del) = (UINT16)(rec & 0xffff); |
| 3104 | W_VREG_S(VDREG, del) = (UINT16)(rec & 0xffff); |
| 3095 | 3105 | |
| 3096 | 3106 | for (i = 0; i < 8; i++) |
| 3097 | 3107 | { |
| r14545 | r14546 | |
| 3183 | 3193 | rsp->reciprocal_res = rec; |
| 3184 | 3194 | rsp->dp_allowed = 0; |
| 3185 | 3195 | |
| 3186 | | VREG_S(VDREG, del) = (UINT16)(rec & 0xffff); |
| 3196 | W_VREG_S(VDREG, del) = (UINT16)(rec & 0xffff); |
| 3187 | 3197 | |
| 3188 | 3198 | for (i = 0; i < 8; i++) |
| 3189 | 3199 | { |
| r14545 | r14546 | |
| 3215 | 3225 | ACCUM_L(i) = VREG_S(VS2REG, sel); |
| 3216 | 3226 | } |
| 3217 | 3227 | |
| 3218 | | VREG_S(VDREG, del) = (INT16)(rsp->reciprocal_res >> 16); |
| 3228 | W_VREG_S(VDREG, del) = (INT16)(rsp->reciprocal_res >> 16); |
| 3219 | 3229 | } |
| 3220 | 3230 | |
| 3221 | 3231 | INLINE void cfunc_rsp_vmov(void *param) |
| r14545 | r14546 | |
| 3232 | 3242 | int del = VS1REG & 7; |
| 3233 | 3243 | int sel = EL & 7; |
| 3234 | 3244 | |
| 3235 | | VREG_S(VDREG, del) = VREG_S(VS2REG, sel); |
| 3245 | W_VREG_S(VDREG, del) = VREG_S(VS2REG, sel); |
| 3236 | 3246 | for (int i = 0; i < 8; i++) |
| 3237 | 3247 | { |
| 3238 | 3248 | sel = VEC_EL_2(EL, i); |
| r14545 | r14546 | |
| 3324 | 3334 | rsp->reciprocal_res = rec; |
| 3325 | 3335 | rsp->dp_allowed = 0; |
| 3326 | 3336 | |
| 3327 | | VREG_S(VDREG, del) = (UINT16)(rec & 0xffff); |
| 3337 | W_VREG_S(VDREG, del) = (UINT16)(rec & 0xffff); |
| 3328 | 3338 | |
| 3329 | 3339 | for (i = 0; i < 8; i++) |
| 3330 | 3340 | { |
| r14545 | r14546 | |
| 3357 | 3367 | ACCUM_L(i) = VREG_S(VS2REG, sel); |
| 3358 | 3368 | } |
| 3359 | 3369 | |
| 3360 | | VREG_S(VDREG, del) = (INT16)(rsp->reciprocal_res >> 16); // store high part |
| 3370 | W_VREG_S(VDREG, del) = (INT16)(rsp->reciprocal_res >> 16); // store high part |
| 3361 | 3371 | } |
| 3362 | 3372 | |
| 3363 | 3373 | static void cfunc_sp_set_status_cb(void *param) |
| r14545 | r14546 | |
| 3477 | 3487 | try |
| 3478 | 3488 | { |
| 3479 | 3489 | /* start the block */ |
| 3480 | | block = drcuml->begin_block(8192); |
| 3490 | block = drcuml->begin_block(4096); |
| 3481 | 3491 | |
| 3482 | 3492 | /* loop until we get through all instruction sequences */ |
| 3483 | 3493 | for (seqhead = desclist; seqhead != NULL; seqhead = seqlast->next()) |
| r14545 | r14546 | |
| 3774 | 3784 | { |
| 3775 | 3785 | if (!(seqhead->flags & OPFLAG_VIRTUAL_NOOP)) |
| 3776 | 3786 | { |
| 3787 | UINT32 sum = seqhead->opptr.l[0]; |
| 3777 | 3788 | void *base = rsp->direct->read_decrypted_ptr(seqhead->physpc | 0x1000); |
| 3778 | 3789 | UML_LOAD(block, I0, base, 0, SIZE_DWORD, SCALE_x4); // load i0,base,0,dword |
| 3779 | | UML_CMP(block, I0, seqhead->opptr.l[0]); // cmp i0,opptr[0] |
| 3790 | |
| 3791 | if (seqhead->delay.first() != NULL && seqhead->physpc != seqhead->delay.first()->physpc) |
| 3792 | { |
| 3793 | base = rsp->direct->read_decrypted_ptr(seqhead->delay.first()->physpc | 0x1000); |
| 3794 | UML_LOAD(block, I1, base, 0, SIZE_DWORD, SCALE_x4); // load i1,base,dword |
| 3795 | UML_ADD(block, I0, I0, I1); // add i0,i0,i1 |
| 3796 | |
| 3797 | sum += seqhead->delay.first()->opptr.l[0]; |
| 3798 | } |
| 3799 | |
| 3800 | UML_CMP(block, I0, sum); // cmp i0,opptr[0] |
| 3780 | 3801 | UML_EXHc(block, COND_NE, *rsp->impstate->nocode, epc(seqhead)); // exne nocode,seqhead->pc |
| 3781 | 3802 | } |
| 3782 | 3803 | } |
| r14545 | r14546 | |
| 3795 | 3816 | UML_LOAD(block, I1, base, 0, SIZE_DWORD, SCALE_x4); // load i1,base,dword |
| 3796 | 3817 | UML_ADD(block, I0, I0, I1); // add i0,i0,i1 |
| 3797 | 3818 | sum += curdesc->opptr.l[0]; |
| 3819 | |
| 3820 | if (curdesc->delay.first() != NULL && (curdesc == seqlast || (curdesc->next() != NULL && curdesc->next()->physpc != curdesc->delay.first()->physpc))) |
| 3821 | { |
| 3822 | base = rsp->direct->read_decrypted_ptr(curdesc->delay.first()->physpc | 0x1000); |
| 3823 | UML_LOAD(block, I1, base, 0, SIZE_DWORD, SCALE_x4); // load i1,base,dword |
| 3824 | UML_ADD(block, I0, I0, I1); // add i0,i0,i1 |
| 3825 | |
| 3826 | sum += curdesc->delay.first()->opptr.l[0]; |
| 3827 | } |
| 3798 | 3828 | } |
| 3799 | 3829 | UML_CMP(block, I0, sum); // cmp i0,sum |
| 3800 | 3830 | UML_EXHc(block, COND_NE, *rsp->impstate->nocode, epc(seqhead)); // exne nocode,seqhead->pc |
| r14545 | r14546 | |
| 3887 | 3917 | { |
| 3888 | 3918 | generate_update_cycles(rsp, block, &compiler_temp, desc->targetpc, TRUE); // <subtract cycles> |
| 3889 | 3919 | if (desc->flags & OPFLAG_INTRABLOCK_BRANCH) |
| 3890 | | { |
| 3891 | 3920 | UML_JMP(block, desc->targetpc | 0x80000000); // jmp desc->targetpc |
| 3892 | | } |
| 3893 | 3921 | else |
| 3894 | | { |
| 3895 | 3922 | UML_HASHJMP(block, 0, desc->targetpc, *rsp->impstate->nocode); |
| 3896 | 3923 | // hashjmp <mode>,desc->targetpc,nocode |
| 3897 | | } |
| 3898 | 3924 | } |
| 3899 | 3925 | else |
| 3900 | 3926 | { |
| r14545 | r14546 | |
| 4751 | 4777 | |
| 4752 | 4778 | case CPUINFO_INT_INPUT_STATE: info->i = CLEAR_LINE; break; |
| 4753 | 4779 | |
| 4754 | | case CPUINFO_INT_PREVIOUSPC: info->i = rsp->ppc; break; |
| 4780 | case CPUINFO_INT_PREVIOUSPC: info->i = rsp->ppc | 0x04000000; break; |
| 4755 | 4781 | |
| 4756 | 4782 | case CPUINFO_INT_PC: /* intentional fallthrough */ |
| 4757 | | case CPUINFO_INT_REGISTER + RSP_PC: info->i = rsp->pc; break; |
| 4783 | case CPUINFO_INT_REGISTER + RSP_PC: info->i = rsp->pc | 0x04000000; break; |
| 4758 | 4784 | |
| 4759 | 4785 | case CPUINFO_INT_REGISTER + RSP_R0: info->i = rsp->r[0]; break; |
| 4760 | 4786 | case CPUINFO_INT_REGISTER + RSP_R1: info->i = rsp->r[1]; break; |
| r14545 | r14546 | |
| 4788 | 4814 | case CPUINFO_INT_REGISTER + RSP_R29: info->i = rsp->r[29]; break; |
| 4789 | 4815 | case CPUINFO_INT_REGISTER + RSP_R30: info->i = rsp->r[30]; break; |
| 4790 | 4816 | case CPUINFO_INT_SP: |
| 4791 | | case CPUINFO_INT_REGISTER + RSP_R31: info->i = rsp->r[31]; break; |
| 4817 | case CPUINFO_INT_REGISTER + RSP_R31: info->i = rsp->r[31]; break; |
| 4792 | 4818 | case CPUINFO_INT_REGISTER + RSP_SR: info->i = rsp->sr; break; |
| 4793 | | case CPUINFO_INT_REGISTER + RSP_NEXTPC: info->i = rsp->nextpc; break; |
| 4819 | case CPUINFO_INT_REGISTER + RSP_NEXTPC: info->i = rsp->nextpc | 0x04000000; break; |
| 4794 | 4820 | case CPUINFO_INT_REGISTER + RSP_STEPCNT: info->i = rsp->step_count; break; |
| 4795 | 4821 | |
| 4796 | 4822 | /* --- the following bits of info are returned as pointers to data or functions --- */ |
| r14545 | r14546 | |
| 4812 | 4838 | |
| 4813 | 4839 | case CPUINFO_STR_FLAGS: strcpy(info->s, " "); break; |
| 4814 | 4840 | |
| 4815 | | case CPUINFO_STR_REGISTER + RSP_PC: sprintf(info->s, "PC: %08X", rsp->pc); break; |
| 4841 | case CPUINFO_STR_REGISTER + RSP_PC: sprintf(info->s, "PC: %08X", rsp->pc | 0x04000000); break; |
| 4816 | 4842 | |
| 4817 | 4843 | case CPUINFO_STR_REGISTER + RSP_R0: sprintf(info->s, "R0: %08X", rsp->r[0]); break; |
| 4818 | 4844 | case CPUINFO_STR_REGISTER + RSP_R1: sprintf(info->s, "R1: %08X", rsp->r[1]); break; |