src/emu/cpu/powerpc/ppcdrc.c
| r2825 | r2826 | |
| 1387 | 1387 | } |
| 1388 | 1388 | |
| 1389 | 1389 | /* adjust cycles */ |
| 1390 | | UML_SUBf(block, MEM(&ppc->icount), MEM(&ppc->icount), IREG(1), FLAGS_S); // sub icount,icount,cycles,S |
| 1390 | UML_SUB(block, MEM(&ppc->icount), MEM(&ppc->icount), IREG(1)); // sub icount,icount,cycles |
| 1391 | 1391 | UML_EXHc(block, IF_S, ppc->impstate->out_of_cycles, IREG(0)); // exh out_of_cycles,i0 |
| 1392 | 1392 | UML_HASHJMP(block, MEM(&ppc->impstate->mode), IREG(0), ppc->impstate->nocode); // hashjmp <mode>,i0,nocode |
| 1393 | 1393 | |
| r2825 | r2826 | |
| 1860 | 1860 | /* account for cycles */ |
| 1861 | 1861 | if (compiler->cycles > 0) |
| 1862 | 1862 | { |
| 1863 | | UML_SUBf(block, MEM(&ppc->icount), MEM(&ppc->icount), MAPVAR_CYCLES, allow_exception ? FLAGS_S : 0); |
| 1864 | | // sub icount,icount,cycles,S |
| 1863 | UML_SUB(block, MEM(&ppc->icount), MEM(&ppc->icount), MAPVAR_CYCLES); // sub icount,icount,cycles |
| 1865 | 1864 | UML_MAPVAR(block, MAPVAR_CYCLES, 0); // mapvar cycles,0 |
| 1866 | 1865 | if (allow_exception) |
| 1867 | 1866 | UML_EXHc(block, IF_S, ppc->impstate->out_of_cycles, PARAM(ptype, pvalue)); // exh out_of_cycles,nextpc |
| r2825 | r2826 | |
| 2106 | 2105 | static void generate_branch(drcuml_block *block, compiler_state *compiler, const opcode_desc *desc, int source, UINT8 link) |
| 2107 | 2106 | { |
| 2108 | 2107 | compiler_state compiler_temp = *compiler; |
| 2108 | UINT32 *srcptr = &ppc->spr[source]; |
| 2109 | 2109 | |
| 2110 | 2110 | /* set the link if needed */ |
| 2111 | 2111 | if (link) |
| 2112 | { |
| 2113 | if (desc->targetpc == BRANCH_TARGET_DYNAMIC && source == SPR_LR) |
| 2114 | { |
| 2115 | UML_MOV(block, MEM(&ppc->impstate->tempaddr), MEM(srcptr)); // mov [tempaddr],[lr] |
| 2116 | srcptr = &ppc->impstate->tempaddr; |
| 2117 | } |
| 2112 | 2118 | UML_MOV(block, SPR32(SPR_LR), IMM(desc->pc + 4)); // mov [lr],desc->pc + 4 |
| 2119 | } |
| 2113 | 2120 | |
| 2114 | 2121 | /* update the cycles and jump through the hash table to the target */ |
| 2115 | 2122 | if (desc->targetpc != BRANCH_TARGET_DYNAMIC) |
| r2825 | r2826 | |
| 2118 | 2125 | if (desc->flags & OPFLAG_INTRABLOCK_BRANCH) |
| 2119 | 2126 | UML_JMP(block, desc->targetpc | 0x80000000); // jmp desc->targetpc | 0x80000000 |
| 2120 | 2127 | else |
| 2121 | | UML_HASHJMP(block, IMM(ppc->impstate->mode), IMM(desc->targetpc), ppc->impstate->nocode); // hashjmp <mode>,desc->targetpc,nocode |
| 2128 | UML_HASHJMP(block, IMM(ppc->impstate->mode), IMM(desc->targetpc), ppc->impstate->nocode); |
| 2129 | // hashjmp <mode>,desc->targetpc,nocode |
| 2122 | 2130 | } |
| 2123 | 2131 | else |
| 2124 | 2132 | { |
| 2125 | | UML_CMP(block, SPR32(source), IMM(0xb032)); |
| 2126 | | UML_MOV(block, MEM(&ppc->impstate->arg0), IMM(desc->pc)); |
| 2127 | | UML_CALLCc(block, IF_E, cfunc_printf_debug, "b032 @ PC=%08X\n"); |
| 2128 | | |
| 2129 | | generate_update_cycles(block, &compiler_temp, SPR32(source), TRUE); // <subtract cycles> |
| 2130 | | UML_HASHJMP(block, IMM(ppc->impstate->mode), SPR32(source), ppc->impstate->nocode); // hashjmp <mode>,<rsreg>,nocode |
| 2133 | generate_update_cycles(block, &compiler_temp, MEM(srcptr), TRUE); // <subtract cycles> |
| 2134 | UML_HASHJMP(block, IMM(ppc->impstate->mode), MEM(srcptr), ppc->impstate->nocode); // hashjmp <mode>,<rsreg>,nocode |
| 2131 | 2135 | } |
| 2132 | 2136 | |
| 2133 | 2137 | /* update the label */ |
| r2825 | r2826 | |
| 2149 | 2153 | |
| 2150 | 2154 | if (!(bo & 0x04)) |
| 2151 | 2155 | { |
| 2152 | | UML_SUBf(block, SPR32(SPR_CTR), SPR32(SPR_CTR), IMM(1), FLAGS_Z); // sub [ctr],[ctr],1,z |
| 2156 | UML_SUB(block, SPR32(SPR_CTR), SPR32(SPR_CTR), IMM(1)); // sub [ctr],[ctr],1 |
| 2153 | 2157 | UML_JMPc(block, (bo & 0x02) ? IF_NZ : IF_Z, skip); // jmp skip,nz/z |
| 2154 | 2158 | } |
| 2155 | 2159 | if (!(bo & 0x10)) |
| r2825 | r2826 | |
| 2223 | 2227 | return TRUE; |
| 2224 | 2228 | |
| 2225 | 2229 | case 0x08: /* SUBFIC */ |
| 2226 | | UML_SUBf(block, R32(G_RD(op)), IMM((INT16)G_SIMM(op)), R32(G_RA(op)), FLAGS_C); // sub rd,simm,ra,c |
| 2230 | UML_SUB(block, R32(G_RD(op)), IMM((INT16)G_SIMM(op)), R32(G_RA(op))); // sub rd,simm,ra |
| 2227 | 2231 | generate_compute_flags(block, FALSE, XER_CA, TRUE); // <update flags> |
| 2228 | 2232 | return TRUE; |
| 2229 | 2233 | |
| 2230 | 2234 | case 0x0c: /* ADDIC */ |
| 2231 | | UML_ADDf(block, R32(G_RD(op)), R32(G_RA(op)), IMM((INT16)G_SIMM(op)), FLAGS_C); // add rd,ra,simm,c |
| 2235 | UML_ADD(block, R32(G_RD(op)), R32(G_RA(op)), IMM((INT16)G_SIMM(op))); // add rd,ra,simm |
| 2232 | 2236 | generate_compute_flags(block, FALSE, XER_CA, FALSE); // <update flags> |
| 2233 | 2237 | return TRUE; |
| 2234 | 2238 | |
| 2235 | 2239 | case 0x0d: /* ADDIC. */ |
| 2236 | | UML_ADDf(block, R32(G_RD(op)), R32(G_RA(op)), IMM((INT16)G_SIMM(op)), FLAGS_C); // add rd,ra,simm,c |
| 2240 | UML_ADD(block, R32(G_RD(op)), R32(G_RA(op)), IMM((INT16)G_SIMM(op))); // add rd,ra,simm |
| 2237 | 2241 | generate_compute_flags(block, TRUE, XER_CA, FALSE); // <update flags> |
| 2238 | 2242 | return TRUE; |
| 2239 | 2243 | |
| r2825 | r2826 | |
| 2299 | 2303 | return TRUE; |
| 2300 | 2304 | |
| 2301 | 2305 | case 0x1c: /* ANDI. */ |
| 2302 | | UML_ANDf(block, R32(G_RA(op)), R32(G_RS(op)), IMM(G_UIMM(op)), FLAGS_RC(op)); // and ra,rs,uimm,FLAGS_RC |
| 2306 | UML_AND(block, R32(G_RA(op)), R32(G_RS(op)), IMM(G_UIMM(op))); // and ra,rs,uimm |
| 2303 | 2307 | generate_compute_flags(block, TRUE, 0, FALSE); // <update flags> |
| 2304 | 2308 | return TRUE; |
| 2305 | 2309 | |
| 2306 | 2310 | case 0x1d: /* ANDIS. */ |
| 2307 | | UML_ANDf(block, R32(G_RA(op)), R32(G_RS(op)), IMM(G_UIMM(op) << 16), FLAGS_RC(op));// and ra,rs,uimm << 16,FLAGS_RC |
| 2311 | UML_AND(block, R32(G_RA(op)), R32(G_RS(op)), IMM(G_UIMM(op) << 16)); // and ra,rs,uimm << 16 |
| 2308 | 2312 | generate_compute_flags(block, TRUE, 0, FALSE); // <update flags> |
| 2309 | 2313 | return TRUE; |
| 2310 | 2314 | |
| r2825 | r2826 | |
| 2748 | 2752 | |
| 2749 | 2753 | case 0x10a: /* ADDx */ |
| 2750 | 2754 | case 0x30a: /* ADDOx */ |
| 2751 | | UML_ADDf(block, R32(G_RD(op)), R32(G_RA(op)), R32(G_RB(op)), FLAGS_RCOE(op)); // add rd,ra,rb,FLAGS_RCOE(op) |
| 2755 | UML_ADD(block, R32(G_RD(op)), R32(G_RA(op)), R32(G_RB(op))); // add rd,ra,rb |
| 2752 | 2756 | generate_compute_flags(block, op & M_RC, ((op & M_OE) ? XER_OV : 0), FALSE); // <update flags> |
| 2753 | 2757 | return TRUE; |
| 2754 | 2758 | |
| 2755 | 2759 | case 0x00a: /* ADDCx */ |
| 2756 | 2760 | case 0x20a: /* ADDCOx */ |
| 2757 | | UML_ADDf(block, R32(G_RD(op)), R32(G_RA(op)), R32(G_RB(op)), FLAGS_RCOECA(op)); // add rd,ra,rb,FLAGS_RCOECA(op) |
| 2761 | UML_ADD(block, R32(G_RD(op)), R32(G_RA(op)), R32(G_RB(op))); // add rd,ra,rb |
| 2758 | 2762 | generate_compute_flags(block, op & M_RC, XER_CA | ((op & M_OE) ? XER_OV : 0), FALSE);// <update flags> |
| 2759 | 2763 | return TRUE; |
| 2760 | 2764 | |
| 2761 | 2765 | case 0x08a: /* ADDEx */ |
| 2762 | 2766 | case 0x28a: /* ADDEOx */ |
| 2763 | 2767 | UML_CARRY(block, SPR32(SPR_XER), IMM(29)); // carry [xer],XER_CA |
| 2764 | | UML_ADDCf(block, R32(G_RD(op)), R32(G_RA(op)), R32(G_RB(op)), FLAGS_RCOECA(op));// addc rd,ra,rb,FLAGS_RCOECA(op) |
| 2768 | UML_ADDC(block, R32(G_RD(op)), R32(G_RA(op)), R32(G_RB(op))); // addc rd,ra,rb |
| 2765 | 2769 | generate_compute_flags(block, op & M_RC, XER_CA | ((op & M_OE) ? XER_OV : 0), FALSE);// <update flags> |
| 2766 | 2770 | return TRUE; |
| 2767 | 2771 | |
| 2768 | 2772 | case 0x0ca: /* ADDZEx */ |
| 2769 | 2773 | case 0x2ca: /* ADDZEOx */ |
| 2770 | 2774 | UML_CARRY(block, SPR32(SPR_XER), IMM(29)); // carry [xer],XER_CA |
| 2771 | | UML_ADDCf(block, R32(G_RD(op)), R32(G_RA(op)), IMM(0), FLAGS_RCOECA(op)); // addc rd,ra,0,FLAGS_RCOECA(op) |
| 2775 | UML_ADDC(block, R32(G_RD(op)), R32(G_RA(op)), IMM(0)); // addc rd,ra,0 |
| 2772 | 2776 | generate_compute_flags(block, op & M_RC, XER_CA | ((op & M_OE) ? XER_OV : 0), FALSE);// <update flags> |
| 2773 | 2777 | return TRUE; |
| 2774 | 2778 | |
| 2775 | 2779 | case 0x0ea: /* ADDMEx */ |
| 2776 | 2780 | case 0x2ea: /* ADDMEOx */ |
| 2777 | 2781 | UML_CARRY(block, SPR32(SPR_XER), IMM(29)); // carry [xer],XER_CA |
| 2778 | | UML_ADDCf(block, R32(G_RD(op)), R32(G_RA(op)), IMM(-1), FLAGS_RCOE(op)); // addc rd,ra,-1,FLAGS_RCOECA(op) |
| 2782 | UML_ADDC(block, R32(G_RD(op)), R32(G_RA(op)), IMM(-1)); // addc rd,ra,-1 |
| 2779 | 2783 | generate_compute_flags(block, op & M_RC, XER_CA | ((op & M_OE) ? XER_OV : 0), FALSE);// <update flags> |
| 2780 | 2784 | return TRUE; |
| 2781 | 2785 | |
| 2782 | 2786 | case 0x028: /* SUBFx */ |
| 2783 | 2787 | case 0x228: /* SUBFOx */ |
| 2784 | | UML_SUBf(block, R32(G_RD(op)), R32(G_RB(op)), R32(G_RA(op)), FLAGS_RCOE(op)); // sub rd,rb,ra,FLAGS_RCOE(op) |
| 2788 | UML_SUB(block, R32(G_RD(op)), R32(G_RB(op)), R32(G_RA(op))); // sub rd,rb,ra |
| 2785 | 2789 | generate_compute_flags(block, op & M_RC, (op & M_OE) ? XER_OV : 0, TRUE); // <update flags> |
| 2786 | 2790 | return TRUE; |
| 2787 | 2791 | |
| 2788 | 2792 | case 0x008: /* SUBFCx */ |
| 2789 | 2793 | case 0x208: /* SUBFCOx */ |
| 2790 | | UML_SUBf(block, R32(G_RD(op)), R32(G_RB(op)), R32(G_RA(op)), FLAGS_RCOECA(op)); // sub rd,rb,ra,FLAGS_RCOECA(op) |
| 2794 | UML_SUB(block, R32(G_RD(op)), R32(G_RB(op)), R32(G_RA(op))); // sub rd,rb,ra |
| 2791 | 2795 | generate_compute_flags(block, op & M_RC, XER_CA | ((op & M_OE) ? XER_OV : 0), TRUE);// <update flags> |
| 2792 | 2796 | return TRUE; |
| 2793 | 2797 | |
| r2825 | r2826 | |
| 2795 | 2799 | case 0x288: /* SUBFEOx */ |
| 2796 | 2800 | UML_XOR(block, IREG(0), SPR32(SPR_XER), IMM(XER_CA)); // xor i0,[xer],XER_CA |
| 2797 | 2801 | UML_CARRY(block, IREG(0), IMM(29)); // carry i0,XER_CA |
| 2798 | | UML_SUBBf(block, R32(G_RD(op)), R32(G_RB(op)), R32(G_RA(op)), FLAGS_RCOECA(op));// subc rd,rb,ra,FLAGS_RCOECA(op) |
| 2802 | UML_SUBB(block, R32(G_RD(op)), R32(G_RB(op)), R32(G_RA(op))); // subc rd,rb,ra |
| 2799 | 2803 | generate_compute_flags(block, op & M_RC, XER_CA | ((op & M_OE) ? XER_OV : 0), TRUE);// <update flags> |
| 2800 | 2804 | return TRUE; |
| 2801 | 2805 | |
| r2825 | r2826 | |
| 2803 | 2807 | case 0x2c8: /* SUBFZEOx */ |
| 2804 | 2808 | UML_XOR(block, IREG(0), SPR32(SPR_XER), IMM(XER_CA)); // xor i0,[xer],XER_CA |
| 2805 | 2809 | UML_CARRY(block, IREG(0), IMM(29)); // carry i0,XER_CA |
| 2806 | | UML_SUBBf(block, R32(G_RD(op)), IMM(0), R32(G_RA(op)), FLAGS_RCOECA(op)); // subc rd,0,ra,FLAGS_RCOECA(op) |
| 2810 | UML_SUBB(block, R32(G_RD(op)), IMM(0), R32(G_RA(op))); // subc rd,0,ra |
| 2807 | 2811 | generate_compute_flags(block, op & M_RC, XER_CA | ((op & M_OE) ? XER_OV : 0), TRUE);// <update flags> |
| 2808 | 2812 | return TRUE; |
| 2809 | 2813 | |
| r2825 | r2826 | |
| 2811 | 2815 | case 0x2e8: /* SUBFMEOx */ |
| 2812 | 2816 | UML_XOR(block, IREG(0), SPR32(SPR_XER), IMM(XER_CA)); // xor i0,[xer],XER_CA |
| 2813 | 2817 | UML_CARRY(block, IREG(0), IMM(29)); // carry i0,XER_CA |
| 2814 | | UML_SUBBf(block, R32(G_RD(op)), IMM(-1), R32(G_RA(op)), FLAGS_RCOECA(op)); // subc rd,-1,ra,,FLAGS_RCOECA(op) |
| 2818 | UML_SUBB(block, R32(G_RD(op)), IMM(-1), R32(G_RA(op))); // subc rd,-1,ra |
| 2815 | 2819 | generate_compute_flags(block, op & M_RC, XER_CA | ((op & M_OE) ? XER_OV : 0), TRUE);// <update flags> |
| 2816 | 2820 | return TRUE; |
| 2817 | 2821 | |
| 2818 | 2822 | case 0x068: /* NEGx */ |
| 2819 | 2823 | case 0x268: /* NEGOx */ |
| 2820 | | UML_SUBf(block, R32(G_RD(op)), IMM(0), R32(G_RA(op)), FLAGS_RCOE(op)); // sub rd,0,ra,FLAGS_RCOE(op) |
| 2824 | UML_SUB(block, R32(G_RD(op)), IMM(0), R32(G_RA(op))); // sub rd,0,ra |
| 2821 | 2825 | generate_compute_flags(block, op & M_RC, (op & M_OE) ? XER_OV : 0, TRUE); // <update flags> |
| 2822 | 2826 | return TRUE; |
| 2823 | 2827 | |
| r2825 | r2826 | |
| 2836 | 2840 | return TRUE; |
| 2837 | 2841 | |
| 2838 | 2842 | case 0x00b: /* MULHWUx */ |
| 2839 | | UML_MULUf(block, IREG(0), R32(G_RD(op)), R32(G_RA(op)), R32(G_RB(op)), FLAGS_RC(op)); |
| 2840 | | // mulu i0,rd,ra,rb,FLAGS_RC(op) |
| 2843 | UML_MULU(block, IREG(0), R32(G_RD(op)), R32(G_RA(op)), R32(G_RB(op))); // mulu i0,rd,ra,rb,FLAGS_RC(op) |
| 2841 | 2844 | generate_compute_flags(block, op & M_RC, 0, FALSE); // <update flags> |
| 2842 | 2845 | return TRUE; |
| 2843 | 2846 | |
| 2844 | 2847 | case 0x04b: /* MULHWx */ |
| 2845 | | UML_MULSf(block, IREG(0), R32(G_RD(op)), R32(G_RA(op)), R32(G_RB(op)), FLAGS_RC(op)); |
| 2846 | | // muls i0,rd,ra,rb,,FLAGS_RC(op) |
| 2848 | UML_MULS(block, IREG(0), R32(G_RD(op)), R32(G_RA(op)), R32(G_RB(op))); // muls i0,rd,ra,rb,,FLAGS_RC(op) |
| 2847 | 2849 | generate_compute_flags(block, op & M_RC, 0, FALSE); // <update flags> |
| 2848 | 2850 | return TRUE; |
| 2849 | 2851 | |
| r2825 | r2826 | |
| 2851 | 2853 | case 0x2eb: /* MULLWOx */ |
| 2852 | 2854 | if (!(op & M_OE)) |
| 2853 | 2855 | { |
| 2854 | | UML_MULSf(block, R32(G_RD(op)), R32(G_RD(op)), R32(G_RA(op)), R32(G_RB(op)), FLAGS_RC(op)); |
| 2855 | | // muls rd,rd,ra,rb,FLAGS_RC(op) |
| 2856 | UML_MULS(block, R32(G_RD(op)), R32(G_RD(op)), R32(G_RA(op)), R32(G_RB(op)));// muls rd,rd,ra,rb,FLAGS_RC(op) |
| 2856 | 2857 | generate_compute_flags(block, op & M_RC, 0, FALSE); // <update flags> |
| 2857 | 2858 | } |
| 2858 | 2859 | else |
| 2859 | 2860 | { |
| 2860 | | UML_MULSf(block, IREG(0), IREG(1), R32(G_RA(op)), R32(G_RB(op)), FLAGS_RC(op)); |
| 2861 | | // muls i0,i1,ra,rb |
| 2861 | UML_MULS(block, IREG(0), IREG(1), R32(G_RA(op)), R32(G_RB(op))); // muls i0,i1,ra,rb |
| 2862 | 2862 | generate_compute_flags(block, op & M_RC, 0, FALSE); // <update flags> |
| 2863 | 2863 | UML_MOV(block, R32(G_RD(op)), IREG(0)); // mov rd,i0 |
| 2864 | 2864 | UML_SAR(block, IREG(0), IREG(0), IMM(31)); // sar i0,i0,31 |
| 2865 | 2865 | UML_AND(block, SPR32(SPR_XER), SPR32(SPR_XER), IMM(XER_OV)); // and [xer],[xer],XER_OV |
| 2866 | | UML_XORf(block, IREG(0), IREG(0), IREG(1), FLAGS_Z); // xor i0,i0,i1,Z |
| 2866 | UML_XOR(block, IREG(0), IREG(0), IREG(1)); // xor i0,i0,i1 |
| 2867 | 2867 | UML_MOVc(block, IF_NZ, IREG(0), IMM(XER_OV | XER_SO)); // mov i0,XER_OV | XER_SO,NZ |
| 2868 | 2868 | UML_OR(block, SPR32(SPR_XER), SPR32(SPR_XER), IREG(0)); // or [xer],[xer],i0 |
| 2869 | 2869 | } |
| r2825 | r2826 | |
| 2871 | 2871 | |
| 2872 | 2872 | case 0x1cb: /* DIVWUx */ |
| 2873 | 2873 | case 0x3cb: /* DIVWUOx */ |
| 2874 | | UML_DIVUf(block, R32(G_RD(op)), R32(G_RD(op)), R32(G_RA(op)), R32(G_RB(op)), FLAGS_RCOE(op)); |
| 2875 | | // divu rd,rd,ra,rb,FLAGS_RCOE(op) |
| 2874 | UML_DIVU(block, R32(G_RD(op)), R32(G_RD(op)), R32(G_RA(op)), R32(G_RB(op))); // divu rd,rd,ra,rb |
| 2876 | 2875 | generate_compute_flags(block, op & M_RC, ((op & M_OE) ? XER_OV : 0), FALSE); // <update flags> |
| 2877 | 2876 | return TRUE; |
| 2878 | 2877 | |
| 2879 | 2878 | case 0x1eb: /* DIVWx */ |
| 2880 | 2879 | case 0x3eb: /* DIVWOx */ |
| 2881 | | UML_DIVSf(block, R32(G_RD(op)), R32(G_RD(op)), R32(G_RA(op)), R32(G_RB(op)), FLAGS_RCOE(op)); |
| 2882 | | // divs rd,rd,ra,rb,FLAGS_RCOE(op) |
| 2880 | UML_DIVS(block, R32(G_RD(op)), R32(G_RD(op)), R32(G_RA(op)), R32(G_RB(op))); // divs rd,rd,ra,rb |
| 2883 | 2881 | generate_compute_flags(block, op & M_RC, ((op & M_OE) ? XER_OV : 0), FALSE); // <update flags> |
| 2884 | 2882 | return TRUE; |
| 2885 | 2883 | |
| 2886 | 2884 | case 0x01c: /* ANDx */ |
| 2887 | | UML_ANDf(block, R32(G_RA(op)), R32(G_RS(op)), R32(G_RB(op)), FLAGS_RC(op)); // and ra,rs,rb,FLAGS_RC(op) |
| 2885 | UML_AND(block, R32(G_RA(op)), R32(G_RS(op)), R32(G_RB(op))); // and ra,rs,rb |
| 2888 | 2886 | generate_compute_flags(block, op & M_RC, 0, FALSE); // <update flags> |
| 2889 | 2887 | return TRUE; |
| 2890 | 2888 | |
| 2891 | 2889 | case 0x03c: /* ANDCx */ |
| 2892 | 2890 | UML_XOR(block, IREG(0), R32(G_RB(op)), IMM(~0)); // xor i0,rb,~0 |
| 2893 | | UML_ANDf(block, R32(G_RA(op)), R32(G_RS(op)), IREG(0), FLAGS_RC(op)); // and ra,rs,i0,FLAGS_RC(op) |
| 2891 | UML_AND(block, R32(G_RA(op)), R32(G_RS(op)), IREG(0)); // and ra,rs,i0 |
| 2894 | 2892 | generate_compute_flags(block, op & M_RC, 0, FALSE); // <update flags> |
| 2895 | 2893 | return TRUE; |
| 2896 | 2894 | |
| 2897 | 2895 | case 0x1dc: /* NANDx */ |
| 2898 | 2896 | UML_AND(block, IREG(0), R32(G_RS(op)), R32(G_RB(op))); // and i0,rs,rb |
| 2899 | | UML_XORf(block, R32(G_RA(op)), IREG(0), IMM(~0), FLAGS_RC(op)); // xor ra,i0,~0,FLAGS_RC(op) |
| 2897 | UML_XOR(block, R32(G_RA(op)), IREG(0), IMM(~0)); // xor ra,i0,~0 |
| 2900 | 2898 | generate_compute_flags(block, op & M_RC, 0, FALSE); // <update flags> |
| 2901 | 2899 | return TRUE; |
| 2902 | 2900 | |
| 2903 | 2901 | case 0x1bc: /* ORx */ |
| 2904 | | UML_ORf(block, R32(G_RA(op)), R32(G_RS(op)), R32(G_RB(op)), FLAGS_RC(op)); // or ra,rs,rb,FLAGS_RC(op) |
| 2902 | UML_OR(block, R32(G_RA(op)), R32(G_RS(op)), R32(G_RB(op))); // or ra,rs,rb |
| 2905 | 2903 | generate_compute_flags(block, op & M_RC, 0, FALSE); // <update flags> |
| 2906 | 2904 | return TRUE; |
| 2907 | 2905 | |
| 2908 | 2906 | case 0x19c: /* ORCx */ |
| 2909 | | UML_XORf(block, IREG(0), R32(G_RB(op)), IMM(~0), FLAGS_RC(op)); // xor i0,rb,~0,FLAGS_RC(op) |
| 2907 | UML_XOR(block, IREG(0), R32(G_RB(op)), IMM(~0)); // xor i0,rb,~0 |
| 2910 | 2908 | UML_OR(block, R32(G_RA(op)), R32(G_RS(op)), IREG(0)); // or ra,rs,i0 |
| 2911 | 2909 | generate_compute_flags(block, op & M_RC, 0, FALSE); // <update flags> |
| 2912 | 2910 | return TRUE; |
| 2913 | 2911 | |
| 2914 | 2912 | case 0x07c: /* NORx */ |
| 2915 | 2913 | UML_OR(block, IREG(0), R32(G_RS(op)), R32(G_RB(op))); // or i0,rs,rb |
| 2916 | | UML_XORf(block, R32(G_RA(op)), IREG(0), IMM(~0), FLAGS_RC(op)); // xor ra,i0,~0,FLAGS_RC(op) |
| 2914 | UML_XOR(block, R32(G_RA(op)), IREG(0), IMM(~0)); // xor ra,i0,~0 |
| 2917 | 2915 | generate_compute_flags(block, op & M_RC, 0, FALSE); // <update flags> |
| 2918 | 2916 | return TRUE; |
| 2919 | 2917 | |
| 2920 | 2918 | case 0x13c: /* XORx */ |
| 2921 | | UML_XORf(block, R32(G_RA(op)), R32(G_RS(op)), R32(G_RB(op)), FLAGS_RC(op)); // xor ra,rs,rb,FLAGS_RC(op) |
| 2919 | UML_XOR(block, R32(G_RA(op)), R32(G_RS(op)), R32(G_RB(op))); // xor ra,rs,rb |
| 2922 | 2920 | generate_compute_flags(block, op & M_RC, 0, FALSE); // <update flags> |
| 2923 | 2921 | return TRUE; |
| 2924 | 2922 | |
| 2925 | 2923 | case 0x11c: /* EQVx */ |
| 2926 | 2924 | UML_XOR(block, IREG(0), R32(G_RS(op)), R32(G_RB(op))); // xor i0,rs,rb |
| 2927 | | UML_XORf(block, R32(G_RA(op)), IREG(0), IMM(~0), FLAGS_RC(op)); // xor ra,i0,~0,FLAGS_RC(op) |
| 2925 | UML_XOR(block, R32(G_RA(op)), IREG(0), IMM(~0)); // xor ra,i0,~0 |
| 2928 | 2926 | generate_compute_flags(block, op & M_RC, 0, FALSE); // <update flags> |
| 2929 | 2927 | return TRUE; |
| 2930 | 2928 | |
| r2825 | r2826 | |
| 2934 | 2932 | return TRUE; |
| 2935 | 2933 | |
| 2936 | 2934 | case 0x218: /* SRWx */ |
| 2937 | | UML_SHRf(block, R32(G_RA(op)), R32(G_RS(op)), R32(G_RB(op)), FLAGS_RC(op)); // shr ra,rs,rb,FLAGS_RC(op) |
| 2935 | UML_SHR(block, R32(G_RA(op)), R32(G_RS(op)), R32(G_RB(op))); // shr ra,rs,rb |
| 2938 | 2936 | generate_compute_flags(block, op & M_RC, 0, FALSE); // <update flags> |
| 2939 | 2937 | return TRUE; |
| 2940 | 2938 | |
| r2825 | r2826 | |
| 2943 | 2941 | UML_XOR(block, IREG(1), IREG(1), IMM(~0)); // xor i1,i1,~0 |
| 2944 | 2942 | UML_AND(block, IREG(0), R32(G_RS(op)), IREG(1)); // and i0,rs,i1 |
| 2945 | 2943 | UML_SAR(block, IREG(1), R32(G_RS(op)), IMM(31)); // sar i1,rs,31 |
| 2946 | | UML_ANDf(block, IREG(0), IREG(0), IREG(1), DRCUML_FLAG_Z); // and i0,i0,i1,z |
| 2944 | UML_AND(block, IREG(0), IREG(0), IREG(1)); // and i0,i0,i1 |
| 2947 | 2945 | UML_SETc(block, IF_NZ, IREG(0)); // set i0,nz |
| 2948 | 2946 | UML_ROLINS(block, SPR32(SPR_XER), IREG(0), IMM(29), IMM(XER_CA)); // rolins [xer],i0,29,XER_CA |
| 2949 | | UML_SARf(block, R32(G_RA(op)), R32(G_RS(op)), R32(G_RB(op)), FLAGS_RC(op)); // sar ra,rs,rb,FLAGS_RC(op) |
| 2947 | UML_SAR(block, R32(G_RA(op)), R32(G_RS(op)), R32(G_RB(op))); // sar ra,rs,rb |
| 2950 | 2948 | generate_compute_flags(block, op & M_RC, 0, FALSE); // <update flags> |
| 2951 | 2949 | return TRUE; |
| 2952 | 2950 | |
| 2953 | 2951 | case 0x338: /* SRAWIx */ |
| 2954 | 2952 | UML_AND(block, IREG(0), R32(G_RS(op)), IMM(~(0xffffffff << (G_SH(op) & 31)))); // and i0,rs,~(0xffffffff << (sh & 31)) |
| 2955 | 2953 | UML_SAR(block, IREG(1), R32(G_RS(op)), IMM(31)); // sar i1,rs,31 |
| 2956 | | UML_ANDf(block, IREG(0), IREG(0), IREG(1), DRCUML_FLAG_Z); // and i0,i0,i1,z |
| 2954 | UML_AND(block, IREG(0), IREG(0), IREG(1)); // and i0,i0,i1 |
| 2957 | 2955 | UML_SETc(block, IF_NZ, IREG(0)); // set i0,nz |
| 2958 | 2956 | UML_ROLINS(block, SPR32(SPR_XER), IREG(0), IMM(29), IMM(XER_CA)); // rolins [xer],i0,29,XER_CA |
| 2959 | | UML_SARf(block, R32(G_RA(op)), R32(G_RS(op)), IMM(G_SH(op)), FLAGS_RC(op)); // sar ra,rs,sh,FLAGS_RC(op) |
| 2957 | UML_SAR(block, R32(G_RA(op)), R32(G_RS(op)), IMM(G_SH(op))); // sar ra,rs,sh |
| 2960 | 2958 | generate_compute_flags(block, op & M_RC, 0, FALSE); // <update flags> |
| 2961 | 2959 | return TRUE; |
| 2962 | 2960 | |
| r2825 | r2826 | |
| 3139 | 3137 | UML_AND(block, MEM(&ppc->impstate->swreg), IREG(2), IMM(0x7f)); // and [swreg],i2,0x7f |
| 3140 | 3138 | UML_XOR(block, IREG(1), IREG(1), IMM(BYTE4_XOR_BE(0))); // xor i1,i1,be_xor(0) |
| 3141 | 3139 | UML_STORE(block, &ppc->r[0], IREG(1), IREG(0), BYTE); // store &r0,i1,i0,byte |
| 3142 | | UML_SUBf(block, MEM(&ppc->impstate->swcount), MEM(&ppc->impstate->swcount), IMM(1), FLAGS_Z); |
| 3143 | | // sub [swcount],[swcount],1,Z |
| 3140 | UML_SUB(block, MEM(&ppc->impstate->swcount), MEM(&ppc->impstate->swcount), IMM(1)); |
| 3141 | // sub [swcount],[swcount],1 |
| 3144 | 3142 | UML_JMPc(block, IF_NZ, swloop); // jmp swloop,NZ |
| 3145 | 3143 | load_fast_iregs(block); // <load fastregs> |
| 3146 | 3144 | generate_update_cycles(block, compiler, IMM(desc->pc + 4), TRUE); // <update cycles> |
| 3147 | 3145 | return TRUE; |
| 3148 | 3146 | |
| 3149 | 3147 | case 0x215: /* LSWX */ |
| 3150 | | UML_ANDf(block, FLAGS_Z, MEM(&ppc->impstate->swcount), SPR32(SPR_XER), IMM(0x7f));// and [swcount],[xer],0x7f,Z |
| 3148 | UML_AND(block, MEM(&ppc->impstate->swcount), SPR32(SPR_XER), IMM(0x7f)); // and [swcount],[xer],0x7f |
| 3151 | 3149 | UML_JMPc(block, IF_Z, swloopend = compiler->labelnum++); // jmp swloopend,Z |
| 3152 | 3150 | UML_ADD(block, MEM(&ppc->impstate->updateaddr), R32Z(G_RA(op)), R32(G_RB(op))); // add [updateaddr],ra,rb |
| 3153 | 3151 | UML_MOV(block, MEM(&ppc->impstate->swreg), IMM(4 * G_RD(op))); // mov [swreg],4*G_RD(op) |
| r2825 | r2826 | |
| 3162 | 3160 | UML_AND(block, MEM(&ppc->impstate->swreg), IREG(2), IMM(0x7f)); // and [swreg],i2,0x7f |
| 3163 | 3161 | UML_XOR(block, IREG(1), IREG(1), IMM(BYTE4_XOR_BE(0))); // xor i1,i1,be_xor(0) |
| 3164 | 3162 | UML_STORE(block, &ppc->r[0], IREG(1), IREG(0), BYTE); // store &r0,i1,i0,byte |
| 3165 | | UML_SUBf(block, MEM(&ppc->impstate->swcount), MEM(&ppc->impstate->swcount), IMM(1), FLAGS_Z); |
| 3166 | | // sub [swcount],[swcount],1,Z |
| 3163 | UML_SUB(block, MEM(&ppc->impstate->swcount), MEM(&ppc->impstate->swcount), IMM(1)); |
| 3164 | // sub [swcount],[swcount],1 |
| 3167 | 3165 | UML_JMPc(block, IF_NZ, swloop); // jmp swloop,NZ |
| 3168 | 3166 | UML_LABEL(block, swloopend); // swloopend: |
| 3169 | 3167 | load_fast_iregs(block); // <load fastregs> |
| r2825 | r2826 | |
| 3319 | 3317 | UML_XOR(block, IREG(1), IREG(1), IMM(BYTE4_XOR_BE(0))); // xor i1,i1,be_xor(0) |
| 3320 | 3318 | UML_LOAD(block, IREG(1), &ppc->r[0], IREG(1), BYTE); // load i1,&r0,i1,byte |
| 3321 | 3319 | UML_CALLH(block, ppc->impstate->write8[ppc->impstate->mode & 3]); // callh write8 |
| 3322 | | UML_SUBf(block, MEM(&ppc->impstate->swcount), MEM(&ppc->impstate->swcount), IMM(1), FLAGS_Z); |
| 3323 | | // sub [swcount],[swcount],1,Z |
| 3320 | UML_SUB(block, MEM(&ppc->impstate->swcount), MEM(&ppc->impstate->swcount), IMM(1)); |
| 3321 | // sub [swcount],[swcount],1 |
| 3324 | 3322 | UML_JMPc(block, IF_NZ, swloop); // jmp swloop,NZ |
| 3325 | 3323 | generate_update_cycles(block, compiler, IMM(desc->pc + 4), TRUE); // <update cycles> |
| 3326 | 3324 | return TRUE; |
| 3327 | 3325 | |
| 3328 | 3326 | case 0x295: /* STSWX */ |
| 3329 | | UML_ANDf(block, FLAGS_Z, MEM(&ppc->impstate->swcount), SPR32(SPR_XER), IMM(0x7f));// and [swcount],[xer],0x7f,Z |
| 3327 | UML_AND(block, MEM(&ppc->impstate->swcount), SPR32(SPR_XER), IMM(0x7f)); // and [swcount],[xer],0x7f |
| 3330 | 3328 | UML_JMPc(block, IF_Z, swloopend = compiler->labelnum++); // jmp swloopend,Z |
| 3331 | 3329 | UML_ADD(block, MEM(&ppc->impstate->updateaddr), R32Z(G_RA(op)), R32(G_RB(op))); // add [updateaddr],ra,rb |
| 3332 | 3330 | UML_MOV(block, MEM(&ppc->impstate->swreg), IMM(4 * G_RS(op))); // mov [swreg],4*G_RS(op) |
| r2825 | r2826 | |
| 3341 | 3339 | UML_XOR(block, IREG(1), IREG(1), IMM(BYTE4_XOR_BE(0))); // xor i1,i1,be_xor(0) |
| 3342 | 3340 | UML_LOAD(block, IREG(1), &ppc->r[0], IREG(1), BYTE); // load i1,&r0,i1,byte |
| 3343 | 3341 | UML_CALLH(block, ppc->impstate->write8[ppc->impstate->mode & 3]); // callh write8 |
| 3344 | | UML_SUBf(block, MEM(&ppc->impstate->swcount), MEM(&ppc->impstate->swcount), IMM(1), FLAGS_Z); |
| 3345 | | // sub [swcount],[swcount],1,Z |
| 3342 | UML_SUB(block, MEM(&ppc->impstate->swcount), MEM(&ppc->impstate->swcount), IMM(1)); |
| 3343 | // sub [swcount],[swcount],1 |
| 3346 | 3344 | UML_JMPc(block, IF_NZ, swloop); // jmp swloop,NZ |
| 3347 | 3345 | UML_LABEL(block, swloopend); // swloopend: |
| 3348 | 3346 | generate_update_cycles(block, compiler, IMM(desc->pc + 4), TRUE); // <update cycles> |