├── srczz ├── zz_11800.h ├── zz_3ce7c.h ├── zz_433a8.h ├── zz_11e80.h ├── zz_11e88.h ├── zz_11e90.h ├── zz_2fff4.h ├── zz_35db0.h ├── zz_35db8.h ├── zz_376d8.h ├── zz_327ac.h ├── zz_2ce28.h ├── zz_4e294.h ├── zz_1c10c.h ├── zz_31878.h ├── zz_4940c.h ├── zz_49424.h ├── zz_494dc.h ├── zz_4b020.h ├── zz_4eeb0.h ├── zz_49f44.h ├── zz_49f54.h ├── zz_49f64.h ├── zz_49f74.h ├── zz_49f84.h ├── zz_49f94.h ├── zz_49fd4.h ├── zz_49fe4.h ├── zz_49ff4.h ├── zz_4a004.h ├── zz_4a024.h ├── zz_4a034.h ├── zz_4a044.h ├── zz_4a4fc.h ├── zz_4a50c.h ├── zz_4a51c.h ├── zz_4a53c.h ├── zz_4a54c.h ├── zz_4a5ec.h ├── zz_4b038.h ├── zz_51300.h ├── zz_5b240.h ├── zz_5b380.h ├── zz_5b390.h ├── zz_5b3a0.h ├── zz_36d1c.h ├── zz_49fa4.h ├── zz_4a014.h ├── zz_4a054.h ├── zz_4a900.h ├── zz_5b260.h ├── zz_5b270.h ├── zz_5b280.h ├── zz_4b050.h ├── zz_4da50.h ├── zz_31868.h ├── zz_340f4.h ├── zz_4b070.h ├── zz_5b250.h ├── zz_18ae8.h ├── zz_3c120.h ├── zz_5729c.h ├── zz_46c3c.h ├── zz_4a1ec.h ├── zz_4c1c4.h ├── zz_439e8.h ├── zz_439fc.h ├── zz_328dc.h ├── zz_46c5c.h ├── zz_493f4.h ├── zz_4a55c.h ├── zz_4a570.h ├── zz_4b8f0.h ├── zz_57a94.h ├── zz_46c2c.h ├── zz_2ffdc.h ├── zz_46cf8.h ├── zz_493dc.h ├── zz_4b450.h ├── zz_4e26c.h ├── zz_4f240.h ├── zz_2cdac.h ├── zz_4f280.h ├── zz_13148.h ├── zz_4aa64.h ├── zz_5772c.h ├── zz_120ec.h ├── zz_4f2a0.h ├── zz_31768.h ├── zz_4b468.h ├── zz_4f260.h ├── zz_164e4.h ├── zz_50018.h ├── zz_50040.h ├── zz_18f84.h ├── zz_43a54.h ├── zz_43a70.h ├── zz_191b0.h ├── zz_43a10.h ├── zz_4f060.h ├── zz_4b9a8.h ├── zz_4e374.h ├── zz_4b728.h ├── zz_43240.h ├── zz_46cd8.h ├── zz_46d98.h ├── zz_46bb4.h ├── zz_46c04.h ├── zz_46db8.h ├── zz_4f220.h ├── zz_243fc.h ├── zz_36648.h ├── zz_52ff4.h ├── zz_550cc.h ├── zz_36480.h ├── zz_50300.h ├── zz_3455c.h ├── zz_43a24.h ├── zz_35dc0.h ├── zz_47214.h ├── zz_46dd0.h ├── zz_1144c.h ├── zz_19f40.h ├── zz_43960.h ├── zz_471b0.h ├── zz_471d0.h ├── zz_31974.h ├── zz_1214c.h ├── zz_1828c.h ├── zz_50e70.h ├── zz_529d0.h ├── zz_54b6c.h ├── zz_54ccc.h ├── zz_55b78.h ├── zz_5659c.h ├── zz_4a138.h ├── zz_15704.h ├── zz_172bc.h ├── zz_1747c.h ├── zz_4e344.h ├── zz_5ab64.h ├── zz_164f4.h ├── zz_4f2b0.h ├── zz_36494.h ├── zz_4f1f0.h ├── zz_4a16c.h ├── zz_46d78.h ├── zz_4f2e0.h ├── zz_52b5c.h ├── zz_52de4.h ├── zz_19f60.h ├── zz_35dd8.h ├── zz_54bd0.h ├── zz_5b358.h ├── zz_43a34.h ├── zz_576fc.h ├── zz_4f1c0.h ├── zz_315a4.h ├── zz_4e2f8.h ├── zz_4b908.h ├── zz_1f260.h ├── zz_4aa04.h ├── zz_56390.h ├── zz_13f80.h ├── zz_4aa8c.h ├── zz_4b6ec.h ├── zz_31570.h ├── zz_4b854.h ├── zz_1402c.h ├── zz_36880.h ├── zz_27410.h ├── zz_471f0.h ├── zz_123bc.h ├── zz_31080.h ├── zz_3636c.h ├── zz_36244.h ├── zz_4a1a4.h ├── zz_4a9a0.h ├── zz_4aff4.h ├── zz_4b17c.h ├── zz_4b424.h ├── zz_5b290.h ├── zz_29a3c.h ├── zz_58e2c.h ├── zz_52fc4.h ├── zz_36394.h ├── zz_4a334.h ├── zz_4a970.h ├── zz_4ec08.h ├── zz_47338.h ├── zz_4d8d8.h ├── zz_54e14.h ├── zz_20178.h ├── zz_23ff0.h ├── zz_4398c.h ├── zz_51590.h ├── zz_58ddc.h ├── zz_1f220.h ├── zz_35f84.h ├── zz_4a41c.h ├── zz_36d24.h ├── zz_4a364.h ├── zz_57a6c.h ├── zz_3a20c.h ├── zz_3c140.h ├── zz_5a660.h ├── zz_4b1a8.h ├── zz_11e24.h ├── zz_233c8.h ├── zz_43328.h ├── zz_31514.h ├── zz_22438.h ├── zz_2ff84.h ├── zz_4a910.h ├── zz_20240.h ├── zz_363f0.h ├── zz_12250.h ├── zz_4fe9c.h ├── zz_2cdcc.h ├── zz_5456c.h ├── zz_116c0.h ├── zz_4e2a8.h ├── zz_1a14c.h ├── zz_4eec8.h ├── zz_4b080.h ├── zz_48504.h ├── zz_4ee84.h ├── zz_5b320.h ├── zz_130fc.h ├── zz_36714.h ├── zz_4a940.h ├── zz_36270.h ├── zz_17028.h ├── zz_362e0.h ├── zz_45ef4.h ├── zz_4a454.h ├── zz_315d8.h ├── zz_4330c.h ├── zz_14c48.h ├── zz_4d1e8.h └── zz_5510c.h ├── srcemu ├── config.h ├── gpu.h ├── stdint.h └── hookemu.sln ├── srcdisasm ├── MIPS │ ├── COPFunction.cs │ ├── REGIMM.cs │ ├── Instructions │ │ ├── NOPInstruction.cs │ │ ├── BREAKInstruction.cs │ │ ├── InvalidInstruction.cs │ │ ├── Multiply │ │ │ ├── MFHIInstruction.cs │ │ │ ├── MFLOInstruction.cs │ │ │ ├── MTHIInstruction.cs │ │ │ ├── MTLOInstruction.cs │ │ │ ├── DIVInstruction.cs │ │ │ ├── DIVUInstruction.cs │ │ │ ├── MULTInstruction.cs │ │ │ └── MULTUInstruction.cs │ │ ├── SYSCALLInstruction.cs │ │ ├── LUIInstruction.cs │ │ ├── Comparison │ │ │ ├── SLTIUInstruction.cs │ │ │ ├── SLTUInstruction.cs │ │ │ ├── SLTIInstruction.cs │ │ │ └── SLTInstruction.cs │ │ ├── Bitshift │ │ │ ├── SRAVInstruction.cs │ │ │ ├── SRAInstruction.cs │ │ │ ├── SLLVInstruction.cs │ │ │ ├── SRLVInstruction.cs │ │ │ ├── SLLInstruction.cs │ │ │ └── SRLInstruction.cs │ │ ├── Arithmetic │ │ │ ├── ADDIInstruction.cs │ │ │ ├── ADDInstruction.cs │ │ │ ├── SUBInstruction.cs │ │ │ └── SUBUInstruction.cs │ │ ├── Bitwise │ │ │ ├── ANDIInstruction.cs │ │ │ ├── XORIInstruction.cs │ │ │ └── ANDInstruction.cs │ │ └── Memory │ │ │ └── Unaligned │ │ │ ├── LWLInstruction.cs │ │ │ ├── LWRInstruction.cs │ │ │ ├── SWLInstruction.cs │ │ │ └── SWRInstruction.cs │ ├── Function.cs │ └── Register.cs ├── PSXException.cs ├── Cutter.cs └── PSXDiscompile.sln ├── src ├── cop0.c ├── cop0.h ├── gool_mips.h ├── gpu.h ├── pad.h ├── core.h ├── pad.c ├── gpu.c ├── rcnt.c ├── irq.c ├── rcnt.h ├── gool.h ├── cdr.h ├── irq.h ├── main.c ├── cdr.c ├── dma.h └── dma.c ├── .gitignore └── Makefile /srczz/zz_11800.h: -------------------------------------------------------------------------------- 1 | ZZ_MARK_NATIVE(0x80011800,0x80011E24,ZZ_11800,CORE_Loop); 2 | -------------------------------------------------------------------------------- /srcemu/config.h: -------------------------------------------------------------------------------- 1 | #ifndef __CONFIG_H__ 2 | #define __CONFIG_H__ 3 | 4 | #define MAXPATHLEN 200 5 | #define PACKAGE_VERSION "C2C PCSX-Reloaded Library" 6 | 7 | #endif 8 | -------------------------------------------------------------------------------- /srczz/zz_3ce7c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_3CE7C: 3 | V1 = A0; 4 | A3 = A1; 5 | ZZ_CLOCKCYCLES(3,0x8003CE88); 6 | goto ZZ_3CE88; 7 | #endif 8 | ZZ_MARK_TARGET(0x8003CE7C,0x8003CE88,ZZ_3CE7C); 9 | -------------------------------------------------------------------------------- /srczz/zz_433a8.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_433A8: 3 | T5 = EMU_ReadU32(GP + 96); //+ 0x60 4 | T6 = EMU_ReadU32(GP + 100); //+ 0x64 5 | #endif 6 | ZZ_MARK_TARGET(0x800433A8,0x800433B0,ZZ_433A8); 7 | -------------------------------------------------------------------------------- /srczz/zz_11e80.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_11E80: 3 | ZZ_JUMPREGISTER_BEGIN(RA); 4 | ZZ_CLOCKCYCLES_JR(2); 5 | ZZ_JUMPREGISTER_END(); 6 | #endif 7 | ZZ_MARK_TARGET(0x80011E80,0x80011E88,ZZ_11E80); 8 | -------------------------------------------------------------------------------- /srczz/zz_11e88.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_11E88: 3 | ZZ_JUMPREGISTER_BEGIN(RA); 4 | ZZ_CLOCKCYCLES_JR(2); 5 | ZZ_JUMPREGISTER_END(); 6 | #endif 7 | ZZ_MARK_TARGET(0x80011E88,0x80011E90,ZZ_11E88); 8 | -------------------------------------------------------------------------------- /srczz/zz_11e90.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_11E90: 3 | ZZ_JUMPREGISTER_BEGIN(RA); 4 | ZZ_CLOCKCYCLES_JR(2); 5 | ZZ_JUMPREGISTER_END(); 6 | #endif 7 | ZZ_MARK_TARGET(0x80011E90,0x80011E98,ZZ_11E90); 8 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/COPFunction.cs: -------------------------------------------------------------------------------- 1 | namespace PSXDiscompile 2 | { 3 | public enum COPFunction 4 | { 5 | MFC = 0, 6 | CFC = 2, 7 | MTC = 4, 8 | CTC = 6 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/REGIMM.cs: -------------------------------------------------------------------------------- 1 | namespace PSXDiscompile 2 | { 3 | public enum REGIMM 4 | { 5 | BLTZ = 0, 6 | BGEZ = 1, 7 | BLTZAL = 16, 8 | BGEZAL = 17 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /srczz/zz_2fff4.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_2FFF4: 3 | ZZ_JUMPREGISTER_BEGIN(RA); 4 | ZZ_CLOCKCYCLES_JR(2); 5 | ZZ_JUMPREGISTER(0x800153E0,ZZ_15340_A0); 6 | ZZ_JUMPREGISTER_END(); 7 | #endif 8 | ZZ_MARK_TARGET(0x8002FFF4,0x8002FFFC,ZZ_2FFF4); 9 | -------------------------------------------------------------------------------- /srczz/zz_35db0.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_35DB0: 3 | ZZ_JUMPREGISTER_BEGIN(RA); 4 | ZZ_CLOCKCYCLES_JR(2); 5 | ZZ_JUMPREGISTER(0x80034920,ZZ_348EC_34); 6 | ZZ_JUMPREGISTER_END(); 7 | #endif 8 | ZZ_MARK_TARGET(0x80035DB0,0x80035DB8,ZZ_35DB0); 9 | -------------------------------------------------------------------------------- /srczz/zz_35db8.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_35DB8: 3 | ZZ_JUMPREGISTER_BEGIN(RA); 4 | ZZ_CLOCKCYCLES_JR(2); 5 | ZZ_JUMPREGISTER(0x8003494C,ZZ_348EC_60); 6 | ZZ_JUMPREGISTER_END(); 7 | #endif 8 | ZZ_MARK_TARGET(0x80035DB8,0x80035DC0,ZZ_35DB8); 9 | -------------------------------------------------------------------------------- /srczz/zz_376d8.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_376D8: 3 | ZZ_JUMPREGISTER_BEGIN(RA); 4 | ZZ_CLOCKCYCLES_JR(2); 5 | ZZ_JUMPREGISTER(0x8003A26C,ZZ_3A234_38); 6 | ZZ_JUMPREGISTER_END(); 7 | #endif 8 | ZZ_MARK_TARGET(0x800376D8,0x800376E0,ZZ_376D8); 9 | -------------------------------------------------------------------------------- /srczz/zz_327ac.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_327AC: 3 | ZZ_JUMPREGISTER_BEGIN(RA); 4 | ZZ_CLOCKCYCLES_JR(2); 5 | ZZ_JUMPREGISTER(0x80037FB8,ZZ_37930_688); 6 | ZZ_JUMPREGISTER_END(); 7 | #endif 8 | ZZ_MARK_TARGET(0x800327AC,0x800327B4,ZZ_327AC); 9 | -------------------------------------------------------------------------------- /src/cop0.c: -------------------------------------------------------------------------------- 1 | #include "cop0.h" 2 | #include "pcsx.h" 3 | 4 | uint32_t COP0_GetRegister(int reg) 5 | { 6 | return PCSX_ReadCOPData(0,reg); 7 | } 8 | 9 | void COP0_SetRegister(int reg,uint32_t value) 10 | { 11 | PCSX_WriteCOPData(0,reg,value); 12 | } 13 | -------------------------------------------------------------------------------- /srczz/zz_2ce28.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_2CE28: 3 | ZZ_JUMPREGISTER_BEGIN(RA); 4 | V0 = -255; 5 | ZZ_CLOCKCYCLES_JR(2); 6 | ZZ_JUMPREGISTER(0x800153E0,ZZ_15340_A0); 7 | ZZ_JUMPREGISTER_END(); 8 | #endif 9 | ZZ_MARK_TARGET(0x8002CE28,0x8002CE30,ZZ_2CE28); 10 | -------------------------------------------------------------------------------- /srczz/zz_4e294.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4E294: 3 | AT = 0x80060000; 4 | AT += A0; 5 | V0 = EMU_ReadU8(AT + 360); //+ 0x168 6 | ZZ_JUMPREGISTER_BEGIN(RA); 7 | ZZ_CLOCKCYCLES_JR(5); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | ZZ_MARK_TARGET(0x8004E294,0x8004E2A8,ZZ_4E294); 11 | -------------------------------------------------------------------------------- /srcemu/gpu.h: -------------------------------------------------------------------------------- 1 | #ifndef __GPU_H__ 2 | #define __GPU_H__ 3 | 4 | #ifdef __cplusplus 5 | extern "C" 6 | { 7 | #endif 8 | 9 | int gpuReadStatus(); 10 | 11 | void psxDma2(u32 madr, u32 bcr, u32 chcr); 12 | void gpuInterrupt(); 13 | 14 | #ifdef __cplusplus 15 | } 16 | #endif 17 | 18 | #endif 19 | -------------------------------------------------------------------------------- /srczz/zz_1c10c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_1C10C: 3 | ZZ_JUMPREGISTER_BEGIN(RA); 4 | EMU_Write16(A0 + 36,R0); //+ 0x24 5 | ZZ_CLOCKCYCLES_JR(2); 6 | ZZ_JUMPREGISTER(0x8001C31C,ZZ_1C114_208); 7 | ZZ_JUMPREGISTER_END(); 8 | #endif 9 | ZZ_MARK_TARGET(0x8001C10C,0x8001C114,ZZ_1C10C); 10 | -------------------------------------------------------------------------------- /srczz/zz_31878.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_31878: 3 | EMU_Write32(GP + 164,A0); //+ 0xA4 4 | ZZ_JUMPREGISTER_BEGIN(RA); 5 | ZZ_CLOCKCYCLES_JR(3); 6 | ZZ_JUMPREGISTER(0x80030038,ZZ_30004_34); 7 | ZZ_JUMPREGISTER_END(); 8 | #endif 9 | ZZ_MARK_TARGET(0x80031878,0x80031884,ZZ_31878); 10 | -------------------------------------------------------------------------------- /srczz/zz_4940c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4940C: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 56; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // exit 11 | ZZ_MARK_TARGET(0x8004940C,0x80049418,ZZ_4940C); 12 | -------------------------------------------------------------------------------- /srczz/zz_49424.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_49424: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 63; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // puts 11 | ZZ_MARK_TARGET(0x80049424,0x80049430,ZZ_49424); 12 | -------------------------------------------------------------------------------- /srczz/zz_494dc.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_494DC: 3 | T2 = 160; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 63; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xA0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // printf 11 | ZZ_MARK_TARGET(0x800494DC,0x800494E8,ZZ_494DC); 12 | -------------------------------------------------------------------------------- /srczz/zz_4b020.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4B020: 3 | T2 = 160; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 19; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xA0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // setjmp 11 | ZZ_MARK_TARGET(0x8004B020,0x8004B02C,ZZ_4B020); 12 | -------------------------------------------------------------------------------- /srczz/zz_4eeb0.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4EEB0: 3 | T2 = 160; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 73; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xA0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // GPU_cw 11 | ZZ_MARK_TARGET(0x8004EEB0,0x8004EEBC,ZZ_4EEB0); 12 | -------------------------------------------------------------------------------- /srczz/zz_49f44.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_49F44: 3 | T2 = 160; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 112; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xA0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // _bu_init 11 | ZZ_MARK_TARGET(0x80049F44,0x80049F50,ZZ_49F44); 12 | -------------------------------------------------------------------------------- /srczz/zz_49f54.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_49F54: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 7; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // DeliverEvent 11 | ZZ_MARK_TARGET(0x80049F54,0x80049F60,ZZ_49F54); 12 | -------------------------------------------------------------------------------- /srczz/zz_49f64.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_49F64: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 8; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // OpenEvent 11 | ZZ_MARK_TARGET(0x80049F64,0x80049F70,ZZ_49F64); 12 | -------------------------------------------------------------------------------- /srczz/zz_49f74.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_49F74: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 9; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // CloseEvent 11 | ZZ_MARK_TARGET(0x80049F74,0x80049F80,ZZ_49F74); 12 | -------------------------------------------------------------------------------- /srczz/zz_49f84.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_49F84: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 11; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // TestEvent 11 | ZZ_MARK_TARGET(0x80049F84,0x80049F90,ZZ_49F84); 12 | -------------------------------------------------------------------------------- /srczz/zz_49f94.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_49F94: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 12; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // EnableEvent 11 | ZZ_MARK_TARGET(0x80049F94,0x80049FA0,ZZ_49F94); 12 | -------------------------------------------------------------------------------- /srczz/zz_49fd4.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_49FD4: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 50; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // FileOpen 11 | ZZ_MARK_TARGET(0x80049FD4,0x80049FE0,ZZ_49FD4); 12 | -------------------------------------------------------------------------------- /srczz/zz_49fe4.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_49FE4: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 52; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // FileRead 11 | ZZ_MARK_TARGET(0x80049FE4,0x80049FF0,ZZ_49FE4); 12 | -------------------------------------------------------------------------------- /srczz/zz_49ff4.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_49FF4: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 53; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // FileWrite 11 | ZZ_MARK_TARGET(0x80049FF4,0x8004A000,ZZ_49FF4); 12 | -------------------------------------------------------------------------------- /srczz/zz_4a004.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A004: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 54; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // FileClose 11 | ZZ_MARK_TARGET(0x8004A004,0x8004A010,ZZ_4A004); 12 | -------------------------------------------------------------------------------- /srczz/zz_4a024.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A024: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 66; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // firstfile 11 | ZZ_MARK_TARGET(0x8004A024,0x8004A030,ZZ_4A024); 12 | -------------------------------------------------------------------------------- /srczz/zz_4a034.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A034: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 67; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // nextfile 11 | ZZ_MARK_TARGET(0x8004A034,0x8004A040,ZZ_4A034); 12 | -------------------------------------------------------------------------------- /srczz/zz_4a044.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A044: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 69; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // FileDelete 11 | ZZ_MARK_TARGET(0x8004A044,0x8004A050,ZZ_4A044); 12 | -------------------------------------------------------------------------------- /srczz/zz_4a4fc.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A4FC: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 18; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // InitPad 11 | ZZ_MARK_TARGET(0x8004A4FC,0x8004A508,ZZ_4A4FC); 12 | -------------------------------------------------------------------------------- /srczz/zz_4a50c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A50C: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 19; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // StartPad 11 | ZZ_MARK_TARGET(0x8004A50C,0x8004A518,ZZ_4A50C); 12 | -------------------------------------------------------------------------------- /srczz/zz_4a51c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A51C: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 20; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // StopPad 11 | ZZ_MARK_TARGET(0x8004A51C,0x8004A528,ZZ_4A51C); 12 | -------------------------------------------------------------------------------- /srczz/zz_4a53c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A53C: 3 | T2 = 192; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 2; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xC0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // SysEnqIntRP 11 | ZZ_MARK_TARGET(0x8004A53C,0x8004A548,ZZ_4A53C); 12 | -------------------------------------------------------------------------------- /srczz/zz_4a54c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A54C: 3 | T2 = 192; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 3; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xC0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // SysDecIntRP 11 | ZZ_MARK_TARGET(0x8004A54C,0x8004A558,ZZ_4A54C); 12 | -------------------------------------------------------------------------------- /srczz/zz_4a5ec.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A5EC: 3 | T2 = 160; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 68; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xA0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // FlushCache 11 | ZZ_MARK_TARGET(0x8004A5EC,0x8004A5F8,ZZ_4A5EC); 12 | -------------------------------------------------------------------------------- /srczz/zz_4b038.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4B038: 3 | T2 = 160; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 114; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xA0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // CdRemove 11 | ZZ_MARK_TARGET(0x8004B038,0x8004B044,ZZ_4B038); 12 | -------------------------------------------------------------------------------- /srczz/zz_51300.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_51300: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 10; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // WaitEvent 11 | ZZ_MARK_TARGET(0x80051300,0x8005130C,ZZ_51300); 12 | -------------------------------------------------------------------------------- /srczz/zz_5b240.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_5B240: 3 | T2 = 160; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 171; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xA0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // CardInfo 11 | ZZ_MARK_TARGET(0x8005B240,0x8005B24C,ZZ_5B240); 12 | -------------------------------------------------------------------------------- /srczz/zz_5b380.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_5B380: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 74; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // InitCard 11 | ZZ_MARK_TARGET(0x8005B380,0x8005B38C,ZZ_5B380); 12 | -------------------------------------------------------------------------------- /srczz/zz_5b390.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_5B390: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 75; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // StartCard 11 | ZZ_MARK_TARGET(0x8005B390,0x8005B39C,ZZ_5B390); 12 | -------------------------------------------------------------------------------- /srczz/zz_5b3a0.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_5B3A0: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 76; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // StopCard 11 | ZZ_MARK_TARGET(0x8005B3A0,0x8005B3AC,ZZ_5B3A0); 12 | -------------------------------------------------------------------------------- /srczz/zz_36d1c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_36D1C: 3 | ZZ_JUMPREGISTER_BEGIN(RA); 4 | ZZ_CLOCKCYCLES_JR(2); 5 | ZZ_JUMPREGISTER(0x80036C70,ZZ_36C10_60); 6 | ZZ_JUMPREGISTER(0x80036CBC,ZZ_36C8C_30); 7 | ZZ_JUMPREGISTER_END(); 8 | #endif 9 | ZZ_MARK_TARGET(0x80036D1C,0x80036D24,ZZ_36D1C); 10 | -------------------------------------------------------------------------------- /srczz/zz_49fa4.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_49FA4: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 13; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // DisableEvent 11 | ZZ_MARK_TARGET(0x80049FA4,0x80049FB0,ZZ_49FA4); 12 | -------------------------------------------------------------------------------- /srczz/zz_4a014.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A014: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 65; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // FormatDevice 11 | ZZ_MARK_TARGET(0x8004A014,0x8004A020,ZZ_4A014); 12 | -------------------------------------------------------------------------------- /srczz/zz_4a054.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A054: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 91; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // ChangeClearPad 11 | ZZ_MARK_TARGET(0x8004A054,0x8004A060,ZZ_4A054); 12 | -------------------------------------------------------------------------------- /srczz/zz_4a900.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A900: 3 | T2 = 192; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 10; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xC0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // ChangeClearRCNT 11 | ZZ_MARK_TARGET(0x8004A900,0x8004A90C,ZZ_4A900); 12 | -------------------------------------------------------------------------------- /srczz/zz_5b260.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_5B260: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 78; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // WriteCardSector 11 | ZZ_MARK_TARGET(0x8005B260,0x8005B26C,ZZ_5B260); 12 | -------------------------------------------------------------------------------- /srczz/zz_5b270.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_5B270: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 79; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // ReadCardSector 11 | ZZ_MARK_TARGET(0x8005B270,0x8005B27C,ZZ_5B270); 12 | -------------------------------------------------------------------------------- /srczz/zz_5b280.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_5B280: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 80; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // AllowNewCard 11 | ZZ_MARK_TARGET(0x8005B280,0x8005B28C,ZZ_5B280); 12 | -------------------------------------------------------------------------------- /srczz/zz_4b050.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4B050: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 23; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // ReturnFromException 11 | ZZ_MARK_TARGET(0x8004B050,0x8004B05C,ZZ_4B050); 12 | -------------------------------------------------------------------------------- /srczz/zz_4da50.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4DA50: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU32(V0 - 8056); //+ 0xFFFFE088 5 | V0 = EMU_ReadU32(V0); 6 | ZZ_JUMPREGISTER_BEGIN(RA); 7 | ZZ_CLOCKCYCLES_JR(6); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | ZZ_MARK_TARGET(0x8004DA50,0x8004DA68,ZZ_4DA50); 11 | -------------------------------------------------------------------------------- /srczz/zz_31868.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_31868: 3 | V0 = 0x3039; 4 | EMU_Write32(GP + 164,V0); //+ 0xA4 5 | ZZ_JUMPREGISTER_BEGIN(RA); 6 | ZZ_CLOCKCYCLES_JR(4); 7 | ZZ_JUMPREGISTER(0x800157A8,ZZ_15738_70); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | ZZ_MARK_TARGET(0x80031868,0x80031878,ZZ_31868); 11 | -------------------------------------------------------------------------------- /srczz/zz_340f4.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_340F4: 3 | V0 = -819; 4 | EMU_Write16(GP + 388,V0); //+ 0x184 5 | ZZ_JUMPREGISTER_BEGIN(RA); 6 | ZZ_CLOCKCYCLES_JR(4); 7 | ZZ_JUMPREGISTER(0x80037FDC,ZZ_37930_6AC); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | ZZ_MARK_TARGET(0x800340F4,0x80034104,ZZ_340F4); 11 | -------------------------------------------------------------------------------- /srczz/zz_4b070.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4B070: 3 | T2 = 176; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 25; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xB0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // SetCustomExitFromException 11 | ZZ_MARK_TARGET(0x8004B070,0x8004B07C,ZZ_4B070); 12 | -------------------------------------------------------------------------------- /srczz/zz_5b250.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_5B250: 3 | T2 = 160; 4 | ZZ_JUMPREGISTER_BEGIN(T2); 5 | T1 = 172; 6 | ZZ_CLOCKCYCLES_JR(3); 7 | ZZ_JUMPREGISTER(0xA0,ZZ_FORCEEXIT); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | // CardAsyncLoadDirectory 11 | ZZ_MARK_TARGET(0x8005B250,0x8005B25C,ZZ_5B250); 12 | -------------------------------------------------------------------------------- /src/cop0.h: -------------------------------------------------------------------------------- 1 | #ifndef H_COP0_H 2 | #define H_COP0_H 3 | 4 | #include "common.h" 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | extern uint32_t COP0_GetRegister(int reg); 11 | extern void COP0_SetRegister(int reg,uint32_t value); 12 | 13 | #ifdef __cplusplus 14 | } 15 | #endif 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /srczz/zz_18ae8.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_18AE8: 3 | ZZ_JUMPREGISTER_BEGIN(RA); 4 | V0 = -255; 5 | ZZ_CLOCKCYCLES_JR(2); 6 | ZZ_JUMPREGISTER(0x80012800,ZZ_126BC_144); 7 | ZZ_JUMPREGISTER(0x80012A58,ZZ_126BC_39C); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | ZZ_MARK_TARGET(0x80018AE8,0x80018AF0,ZZ_18AE8); 11 | -------------------------------------------------------------------------------- /srczz/zz_3c120.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_3C120: 3 | V1 = 0x80040000; 4 | V1 -= 16068; 5 | V0 = EMU_ReadU32(V1); 6 | V0 += 1; 7 | ZZ_JUMPREGISTER_BEGIN(RA); 8 | EMU_Write32(V1,V0); 9 | ZZ_CLOCKCYCLES_JR(7); 10 | ZZ_JUMPREGISTER_END(); 11 | #endif 12 | ZZ_MARK_TARGET(0x8003C120,0x8003C13C,ZZ_3C120); 13 | -------------------------------------------------------------------------------- /srczz/zz_5729c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_5729C: 3 | AT = 0x80060000; 4 | EMU_Write16(AT + 11776,R0); //+ 0x2E00 5 | ZZ_JUMPREGISTER_BEGIN(RA); 6 | ZZ_CLOCKCYCLES_JR(4); 7 | ZZ_JUMPREGISTER(0x800564C0,ZZ_563F0_D0); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | ZZ_MARK_TARGET(0x8005729C,0x800572AC,ZZ_5729C); 11 | -------------------------------------------------------------------------------- /srczz/zz_46c3c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_46C3C: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU8(V0 - 13692); //+ 0xFFFFCA84 5 | ZZ_JUMPREGISTER_BEGIN(RA); 6 | ZZ_CLOCKCYCLES_JR(4); 7 | ZZ_JUMPREGISTER(0x80049088,ZZ_48F5C_12C); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | ZZ_MARK_TARGET(0x80046C3C,0x80046C4C,ZZ_46C3C); 11 | -------------------------------------------------------------------------------- /srczz/zz_4a1ec.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A1EC: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU32(V0 - 12808); //+ 0xFFFFCDF8 5 | ZZ_JUMPREGISTER_BEGIN(RA); 6 | ZZ_CLOCKCYCLES_JR(4); 7 | ZZ_JUMPREGISTER(0x8005B2F0,ZZ_5B2C8_28); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | ZZ_MARK_TARGET(0x8004A1EC,0x8004A1FC,ZZ_4A1EC); 11 | -------------------------------------------------------------------------------- /srczz/zz_4c1c4.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4C1C4: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU8(V0 - 8268); //+ 0xFFFFDFB4 5 | ZZ_JUMPREGISTER_BEGIN(RA); 6 | ZZ_CLOCKCYCLES_JR(4); 7 | ZZ_JUMPREGISTER(0x80015894,ZZ_15738_15C); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | ZZ_MARK_TARGET(0x8004C1C4,0x8004C1D4,ZZ_4C1C4); 11 | -------------------------------------------------------------------------------- /src/gool_mips.h: -------------------------------------------------------------------------------- 1 | #ifndef H_GOOL_MIPS_H 2 | #define H_GOOL_MIPS_H 3 | 4 | #include "gool.h" 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | extern void GOOL_MIPS_ExecuteOnce(struct goolenv *env); 11 | extern void GOOL_MIPS_ExecuteFromZZ(uint32_t pc); 12 | 13 | #ifdef __cplusplus 14 | } 15 | #endif 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /srczz/zz_439e8.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_439E8: 3 | T1 = 0x3FC0000; 4 | T1 |= 0x3FC; 5 | T2 = 0xFFFE0000; 6 | ZZ_JUMPREGISTER_BEGIN(RA); 7 | T2 |= 0xFFFF; 8 | ZZ_CLOCKCYCLES_JR(5); 9 | ZZ_JUMPREGISTER(0x8004024C,ZZ_3FFAC_2A0); 10 | ZZ_JUMPREGISTER_END(); 11 | #endif 12 | ZZ_MARK_TARGET(0x800439E8,0x800439FC,ZZ_439E8); 13 | -------------------------------------------------------------------------------- /srczz/zz_439fc.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_439FC: 3 | T1 = 0xFF0000; 4 | T1 |= 0xFF; 5 | T2 = 0xFFFE0000; 6 | ZZ_JUMPREGISTER_BEGIN(RA); 7 | T2 |= 0xFFFF; 8 | ZZ_CLOCKCYCLES_JR(5); 9 | ZZ_JUMPREGISTER(0x800412FC,ZZ_40FAC_350); 10 | ZZ_JUMPREGISTER_END(); 11 | #endif 12 | ZZ_MARK_TARGET(0x800439FC,0x80043A10,ZZ_439FC); 13 | -------------------------------------------------------------------------------- /srczz/zz_328dc.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_328DC: 3 | EMU_Write16(GP + 364,A0); //+ 0x16C 4 | ZZ_JUMPREGISTER_BEGIN(RA); 5 | ZZ_CLOCKCYCLES_JR(3); 6 | ZZ_JUMPREGISTER(0x80032868,ZZ_327B4_B4); 7 | ZZ_JUMPREGISTER(0x80033814,ZZ_337BC_58); 8 | ZZ_JUMPREGISTER_END(); 9 | #endif 10 | ZZ_MARK_TARGET(0x800328DC,0x800328E8,ZZ_328DC); 11 | -------------------------------------------------------------------------------- /srczz/zz_46c5c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_46C5C: 3 | V0 = 0x80060000; 4 | V0 -= 13696; 5 | ZZ_JUMPREGISTER_BEGIN(RA); 6 | ZZ_CLOCKCYCLES_JR(4); 7 | ZZ_JUMPREGISTER(0x8004903C,ZZ_48F5C_E0); 8 | ZZ_JUMPREGISTER(0x800490C4,ZZ_48F5C_168); 9 | ZZ_JUMPREGISTER_END(); 10 | #endif 11 | ZZ_MARK_TARGET(0x80046C5C,0x80046C6C,ZZ_46C5C); 12 | -------------------------------------------------------------------------------- /srczz/zz_493f4.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_493F4: 3 | V1 = 0x80060000; 4 | V1 -= 12888; 5 | V0 = EMU_ReadU32(V1); 6 | EMU_Write32(V1,A0); 7 | ZZ_JUMPREGISTER_BEGIN(RA); 8 | ZZ_CLOCKCYCLES_JR(6); 9 | ZZ_JUMPREGISTER(0x80046B78,ZZ_46B1C_5C); 10 | ZZ_JUMPREGISTER_END(); 11 | #endif 12 | ZZ_MARK_TARGET(0x800493F4,0x8004940C,ZZ_493F4); 13 | -------------------------------------------------------------------------------- /srczz/zz_4a55c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A55C: 3 | T1 = 0x80060000; 4 | T1 = EMU_ReadU32(T1 - 2620); //+ 0xFFFFF5C4 5 | ZZ_JUMPREGISTER_BEGIN(T1); 6 | ZZ_CLOCKCYCLES_JR(5); 7 | // UNIMPLEMENTED INDIRECT JUMP (T1,8004A568) 8 | // PC IS 8004A568 9 | ZZ_JUMPREGISTER_END(); 10 | #endif 11 | ZZ_MARK_TARGET(0x8004A55C,0x8004A570,ZZ_4A55C); 12 | -------------------------------------------------------------------------------- /srczz/zz_4a570.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A570: 3 | T1 = 0x80060000; 4 | T1 = EMU_ReadU32(T1 - 2616); //+ 0xFFFFF5C8 5 | ZZ_JUMPREGISTER_BEGIN(T1); 6 | ZZ_CLOCKCYCLES_JR(5); 7 | // UNIMPLEMENTED INDIRECT JUMP (T1,8004A57C) 8 | // PC IS 8004A57C 9 | ZZ_JUMPREGISTER_END(); 10 | #endif 11 | ZZ_MARK_TARGET(0x8004A570,0x8004A584,ZZ_4A570); 12 | -------------------------------------------------------------------------------- /srczz/zz_4b8f0.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4B8F0: 3 | V1 = 0xFF0000; 4 | V0 = EMU_ReadU32(A0); 5 | V1 |= 0xFFFF; 6 | V0 |= V1; 7 | ZZ_JUMPREGISTER_BEGIN(RA); 8 | EMU_Write32(A0,V0); 9 | ZZ_CLOCKCYCLES_JR(6); 10 | ZZ_JUMPREGISTER(0x80016184,ZZ_16140_44); 11 | ZZ_JUMPREGISTER_END(); 12 | #endif 13 | ZZ_MARK_TARGET(0x8004B8F0,0x8004B908,ZZ_4B8F0); 14 | -------------------------------------------------------------------------------- /srczz/zz_57a94.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_57A94: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU32(V0 - 5476); //+ 0xFFFFEA9C 5 | V0 ^= 0x1; 6 | ZZ_JUMPREGISTER_BEGIN(RA); 7 | V0 = R0 < V0; 8 | ZZ_CLOCKCYCLES_JR(6); 9 | ZZ_JUMPREGISTER(0x8005ABCC,ZZ_5AB94_38); 10 | ZZ_JUMPREGISTER_END(); 11 | #endif 12 | ZZ_MARK_TARGET(0x80057A94,0x80057AAC,ZZ_57A94); 13 | -------------------------------------------------------------------------------- /srczz/zz_46c2c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_46C2C: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU8(V0 - 13708); //+ 0xFFFFCA74 5 | ZZ_JUMPREGISTER_BEGIN(RA); 6 | ZZ_CLOCKCYCLES_JR(4); 7 | ZZ_JUMPREGISTER(0x80048FAC,ZZ_48F5C_50); 8 | ZZ_JUMPREGISTER(0x800492E0,ZZ_4920C_D4); 9 | ZZ_JUMPREGISTER_END(); 10 | #endif 11 | ZZ_MARK_TARGET(0x80046C2C,0x80046C3C,ZZ_46C2C); 12 | -------------------------------------------------------------------------------- /src/gpu.h: -------------------------------------------------------------------------------- 1 | #ifndef H_GPU_H 2 | #define H_GPU_H 3 | 4 | #include "common.h" 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | extern uint32_t GPU_Read(void); 11 | extern void GPU_Write(uint32_t value); 12 | extern void GPU_WriteAlt(uint32_t value); 13 | 14 | extern uint32_t GPU_GetStatus(void); 15 | 16 | #ifdef __cplusplus 17 | } 18 | #endif 19 | 20 | #endif 21 | -------------------------------------------------------------------------------- /src/pad.h: -------------------------------------------------------------------------------- 1 | #ifndef H_PAD_H 2 | #define H_PAD_H 3 | 4 | #include "common.h" 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | extern uint8_t PAD_Read(void); 11 | extern void PAD_Write(uint8_t value); 12 | 13 | extern uint16_t PAD_GetStatus(void); 14 | 15 | extern void PAD_SetControl(uint16_t value); 16 | 17 | #ifdef __cplusplus 18 | } 19 | #endif 20 | 21 | #endif 22 | -------------------------------------------------------------------------------- /srczz/zz_2ffdc.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_2FFDC: 3 | AT = 0x80060000; 4 | EMU_Write32(AT - 2448,R0); //+ 0xFFFFF670 5 | AT = 0x80070000; 6 | EMU_Write32(AT - 12372,R0); //+ 0xFFFFCFAC 7 | ZZ_JUMPREGISTER_BEGIN(RA); 8 | ZZ_CLOCKCYCLES_JR(6); 9 | ZZ_JUMPREGISTER(0x80014FC8,ZZ_14D6C_25C); 10 | ZZ_JUMPREGISTER_END(); 11 | #endif 12 | ZZ_MARK_TARGET(0x8002FFDC,0x8002FFF4,ZZ_2FFDC); 13 | -------------------------------------------------------------------------------- /srczz/zz_46cf8.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_46CF8: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU32(V0 - 13712); //+ 0xFFFFCA70 5 | AT = 0x80060000; 6 | EMU_Write32(AT - 13712,A0); //+ 0xFFFFCA70 7 | ZZ_JUMPREGISTER_BEGIN(RA); 8 | ZZ_CLOCKCYCLES_JR(6); 9 | ZZ_JUMPREGISTER(0x80015798,ZZ_15738_60); 10 | ZZ_JUMPREGISTER_END(); 11 | #endif 12 | ZZ_MARK_TARGET(0x80046CF8,0x80046D10,ZZ_46CF8); 13 | -------------------------------------------------------------------------------- /srczz/zz_493dc.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_493DC: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU32(V0 - 12940); //+ 0xFFFFCD74 5 | AT = 0x80060000; 6 | EMU_Write32(AT - 12940,A0); //+ 0xFFFFCD74 7 | ZZ_JUMPREGISTER_BEGIN(RA); 8 | ZZ_CLOCKCYCLES_JR(6); 9 | ZZ_JUMPREGISTER(0x80046B70,ZZ_46B1C_54); 10 | ZZ_JUMPREGISTER_END(); 11 | #endif 12 | ZZ_MARK_TARGET(0x800493DC,0x800493F4,ZZ_493DC); 13 | -------------------------------------------------------------------------------- /srczz/zz_4b450.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4B450: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU32(V0 - 8352); //+ 0xFFFFDF60 5 | AT = 0x80060000; 6 | EMU_Write32(AT - 8352,A0); //+ 0xFFFFDF60 7 | ZZ_JUMPREGISTER_BEGIN(RA); 8 | ZZ_CLOCKCYCLES_JR(6); 9 | ZZ_JUMPREGISTER(0x80015764,ZZ_15738_2C); 10 | ZZ_JUMPREGISTER_END(); 11 | #endif 12 | ZZ_MARK_TARGET(0x8004B450,0x8004B468,ZZ_4B450); 13 | -------------------------------------------------------------------------------- /src/core.h: -------------------------------------------------------------------------------- 1 | #ifndef H_CORE_H 2 | #define H_CORE_H 3 | 4 | #include "common.h" 5 | #include "emu.h" 6 | 7 | #ifdef __cplusplus 8 | extern "C" { 9 | #endif 10 | 11 | extern int CORE_Main(void); 12 | extern void CORE_Loop(uint32_t levelid); 13 | extern void CORE_Start(void); 14 | extern void CORE_VSync(int32_t count,int32_t timeout); 15 | 16 | #ifdef __cplusplus 17 | } 18 | #endif 19 | 20 | #endif 21 | -------------------------------------------------------------------------------- /srczz/zz_4e26c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4E26C: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU32(V0 - 8056); //+ 0xFFFFE088 5 | EMU_Write32(V0,A0); 6 | V0 = A0 >> 24; 7 | AT = 0x80060000; 8 | AT += V0; 9 | EMU_Write8(AT + 360,A0); //+ 0x168 10 | ZZ_JUMPREGISTER_BEGIN(RA); 11 | ZZ_CLOCKCYCLES_JR(10); 12 | ZZ_JUMPREGISTER_END(); 13 | #endif 14 | ZZ_MARK_TARGET(0x8004E26C,0x8004E294,ZZ_4E26C); 15 | -------------------------------------------------------------------------------- /src/pad.c: -------------------------------------------------------------------------------- 1 | #include "pad.h" 2 | #include "pcsx.h" 3 | 4 | uint8_t PAD_Read(void) 5 | { 6 | return PCSX_Read8(0x1F801040); 7 | } 8 | 9 | void PAD_Write(uint8_t value) 10 | { 11 | PCSX_Write8(0x1F801040,value); 12 | } 13 | 14 | uint16_t PAD_GetStatus(void) 15 | { 16 | return PCSX_Read16(0x1F801044); 17 | } 18 | 19 | void PAD_SetControl(uint16_t value) 20 | { 21 | PCSX_Write16(0x1F80104A,value); 22 | } 23 | -------------------------------------------------------------------------------- /srczz/zz_4f240.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4F240: 3 | EMU_Write32(A0,GTE_GetRegister(GTE_DREG_SZ1)); 4 | EMU_Write32(A1,GTE_GetRegister(GTE_DREG_SZ2)); 5 | EMU_Write32(A2,GTE_GetRegister(GTE_DREG_SZ3)); 6 | ZZ_JUMPREGISTER_BEGIN(RA); 7 | ZZ_CLOCKCYCLES_JR(5); 8 | ZZ_JUMPREGISTER(0x8001F088,ZZ_1EFA8_E0); 9 | ZZ_JUMPREGISTER_END(); 10 | #endif 11 | ZZ_MARK_TARGET(0x8004F240,0x8004F254,ZZ_4F240); 12 | -------------------------------------------------------------------------------- /src/gpu.c: -------------------------------------------------------------------------------- 1 | #include "gpu.h" 2 | #include "pcsx.h" 3 | 4 | uint32_t GPU_Read(void) 5 | { 6 | return PCSX_Read32(0x1F801810); 7 | } 8 | 9 | void GPU_Write(uint32_t value) 10 | { 11 | PCSX_Write32(0x1F801810,value); 12 | } 13 | 14 | void GPU_WriteAlt(uint32_t value) 15 | { 16 | PCSX_Write32(0x1F801814,value); 17 | } 18 | 19 | uint32_t GPU_GetStatus(void) 20 | { 21 | return PCSX_Read32(0x1F801814); 22 | } 23 | -------------------------------------------------------------------------------- /src/rcnt.c: -------------------------------------------------------------------------------- 1 | #include "rcnt.h" 2 | #include "pcsx.h" 3 | 4 | uint16_t RCNT_GetValue(int counter) 5 | { 6 | return PCSX_Read16(0x1F801100 + counter * 0x10); 7 | } 8 | 9 | void RCNT_SetMode(int counter,uint16_t value) 10 | { 11 | PCSX_Write16(0x1F801104 + counter * 0x10,value); 12 | } 13 | 14 | void RCNT_SetTarget(int counter,uint16_t value) 15 | { 16 | PCSX_Write16(0x1F801108 + counter * 0x10,value); 17 | } 18 | -------------------------------------------------------------------------------- /srczz/zz_2cdac.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_2CDAC: 3 | V1 = 0x80070000; 4 | V1 -= 12800; 5 | V0 = V1 + 1044; 6 | EMU_Write32(V1,V0); 7 | AT = 0x80070000; 8 | EMU_Write32(AT - 12796,R0); //+ 0xFFFFCE04 9 | ZZ_JUMPREGISTER_BEGIN(RA); 10 | ZZ_CLOCKCYCLES_JR(8); 11 | ZZ_JUMPREGISTER(0x8001C410,ZZ_1C3D4_3C); 12 | ZZ_JUMPREGISTER_END(); 13 | #endif 14 | ZZ_MARK_TARGET(0x8002CDAC,0x8002CDCC,ZZ_2CDAC); 15 | -------------------------------------------------------------------------------- /srczz/zz_4f280.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4F280: 3 | A0 <<= 16; 4 | A1 <<= 16; 5 | GTE_SetRegister(GTE_CREG_OFX,A0); 6 | GTE_SetRegister(GTE_CREG_OFY,A1); 7 | ZZ_JUMPREGISTER_BEGIN(RA); 8 | ZZ_CLOCKCYCLES_JR(6); 9 | ZZ_JUMPREGISTER(0x80017AF8,ZZ_17AB0_48); 10 | ZZ_JUMPREGISTER(0x8001809C,ZZ_17CE8_3B4); 11 | ZZ_JUMPREGISTER_END(); 12 | #endif 13 | ZZ_MARK_TARGET(0x8004F280,0x8004F298,ZZ_4F280); 14 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | !.gitignore 2 | *.exe 3 | *.dll 4 | *.stackdump 5 | *.exp 6 | *.lib 7 | *.pdb 8 | src/*.o 9 | src/*.d 10 | 11 | memcard1 12 | c2c.bin 13 | SCES_009.67 14 | 15 | srcemu/Debug 16 | srcemu/hookemu.ncb 17 | srcemu/hookemu.suo 18 | srcemu/hookemu.vcproj.* 19 | 20 | srcdisasm/obj 21 | srcdisasm/bin 22 | srcdisasm/PSXDiscompile.suo 23 | srcdisasm/PSXDiscompile.csproj.* 24 | 25 | zz_map.txt 26 | zz_dis.txt 27 | -------------------------------------------------------------------------------- /srczz/zz_13148.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_13148: 3 | V0 = 0x2; 4 | EMU_Write16(A0 + 4,V0); //+ 0x4 5 | V0 = 0x1; 6 | EMU_Write32(A0 + 28,V0); //+ 0x1C 7 | V0 = -16; 8 | ZZ_JUMPREGISTER_BEGIN(RA); 9 | EMU_Write32(A0 + 36,A0); //+ 0x24 10 | ZZ_CLOCKCYCLES_JR(7); 11 | ZZ_JUMPREGISTER(0x800134E4,ZZ_13304_1E0); 12 | ZZ_JUMPREGISTER_END(); 13 | #endif 14 | ZZ_MARK_TARGET(0x80013148,0x80013164,ZZ_13148); 15 | -------------------------------------------------------------------------------- /srczz/zz_4aa64.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4AA64: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU16(V0 - 12682); //+ 0xFFFFCE76 5 | ZZ_JUMPREGISTER_BEGIN(RA); 6 | ZZ_CLOCKCYCLES_JR(4); 7 | ZZ_JUMPREGISTER(0x80047A7C,ZZ_47940_13C); 8 | ZZ_JUMPREGISTER(0x80048174,ZZ_47E8C_2E8); 9 | ZZ_JUMPREGISTER(0x80047D04,ZZ_47BC0_144); 10 | ZZ_JUMPREGISTER_END(); 11 | #endif 12 | ZZ_MARK_TARGET(0x8004AA64,0x8004AA74,ZZ_4AA64); 13 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/NOPInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class NOPInstruction : Instruction 6 | { 7 | public override string ToString() 8 | { 9 | return "NOP"; 10 | } 11 | 12 | public override void Discompile(Program p,int address,bool direct) 13 | { 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /srczz/zz_5772c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_5772C: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU32(V0 - 5528); //+ 0xFFFFEA68 5 | A0 <<= 4; 6 | A0 += V0; 7 | V0 = EMU_ReadU16(A0 + 12); //+ 0xC 8 | ZZ_JUMPREGISTER_BEGIN(RA); 9 | EMU_Write16(A1,V0); 10 | ZZ_CLOCKCYCLES_JR(7); 11 | ZZ_JUMPREGISTER(0x80057340,ZZ_572C0_80); 12 | ZZ_JUMPREGISTER_END(); 13 | #endif 14 | ZZ_MARK_TARGET(0x8005772C,0x80057748,ZZ_5772C); 15 | -------------------------------------------------------------------------------- /srczz/zz_120ec.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_120EC: 3 | AT = 0x80060000; 4 | AT += A0; 5 | V0 = EMU_ReadU8(AT - 19408); //+ 0xFFFFB430 6 | ZZ_JUMPREGISTER_BEGIN(RA); 7 | ZZ_CLOCKCYCLES_JR(5); 8 | ZZ_JUMPREGISTER(0x8003021C,ZZ_30164_B8); 9 | ZZ_JUMPREGISTER(0x80015094,ZZ_14D6C_328); 10 | ZZ_JUMPREGISTER(0x8002EC1C,ZZ_2EB98_84); 11 | ZZ_JUMPREGISTER_END(); 12 | #endif 13 | ZZ_MARK_TARGET(0x800120EC,0x80012100,ZZ_120EC); 14 | -------------------------------------------------------------------------------- /srczz/zz_4f2a0.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4F2A0: 3 | GTE_SetRegister(GTE_CREG_H,A0); 4 | ZZ_JUMPREGISTER_BEGIN(RA); 5 | ZZ_CLOCKCYCLES_JR(3); 6 | ZZ_JUMPREGISTER(0x80017AEC,ZZ_17AB0_3C); 7 | ZZ_JUMPREGISTER(0x8002FBC8,ZZ_2F9D4_1F4); 8 | ZZ_JUMPREGISTER(0x80016FF0,ZZ_16D84_26C); 9 | ZZ_JUMPREGISTER(0x80020AF4,ZZ_20304_7F0); 10 | ZZ_JUMPREGISTER_END(); 11 | #endif 12 | ZZ_MARK_TARGET(0x8004F2A0,0x8004F2AC,ZZ_4F2A0); 13 | -------------------------------------------------------------------------------- /src/irq.c: -------------------------------------------------------------------------------- 1 | #include "irq.h" 2 | #include "pcsx.h" 3 | 4 | extern uint16_t IRQ_GetStatus(void) 5 | { 6 | return PCSX_Read16(0x1F801070); 7 | } 8 | 9 | extern void IRQ_AcknowledgeBits(uint16_t value) 10 | { 11 | return PCSX_Write16(0x1F801070,value); 12 | } 13 | 14 | uint16_t IRQ_GetMask(void) 15 | { 16 | return PCSX_Read16(0x1F801074); 17 | } 18 | 19 | void IRQ_SetMask(uint16_t value) 20 | { 21 | PCSX_Write16(0x1F801074,value); 22 | } 23 | -------------------------------------------------------------------------------- /srczz/zz_31768.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_31768: 3 | A1 = A1 - A0; 4 | A1 <<= 20; 5 | A1 = (int32_t)A1 >> 21; 6 | A0 += A1; 7 | ZZ_JUMPREGISTER_BEGIN(RA); 8 | V0 = A0 & 0xFFF; 9 | ZZ_CLOCKCYCLES_JR(6); 10 | ZZ_JUMPREGISTER(0x800235D4,ZZ_23424_1B0); 11 | ZZ_JUMPREGISTER(0x800235E8,ZZ_23424_1C4); 12 | ZZ_JUMPREGISTER(0x800235FC,ZZ_23424_1D8); 13 | ZZ_JUMPREGISTER_END(); 14 | #endif 15 | ZZ_MARK_TARGET(0x80031768,0x80031780,ZZ_31768); 16 | -------------------------------------------------------------------------------- /srczz/zz_4b468.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4B468: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU32(V0 - 8352); //+ 0xFFFFDF60 5 | ZZ_JUMPREGISTER_BEGIN(RA); 6 | ZZ_CLOCKCYCLES_JR(4); 7 | ZZ_JUMPREGISTER(0x800567B4,ZZ_567A0_14); 8 | ZZ_JUMPREGISTER(0x8004B668,ZZ_4B634_34); 9 | ZZ_JUMPREGISTER(0x8004CCEC,ZZ_4CBA8_144); 10 | ZZ_JUMPREGISTER(0x8004CF3C,ZZ_4CBA8_394); 11 | ZZ_JUMPREGISTER_END(); 12 | #endif 13 | ZZ_MARK_TARGET(0x8004B468,0x8004B478,ZZ_4B468); 14 | -------------------------------------------------------------------------------- /srczz/zz_4f260.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4F260: 3 | A0 <<= 4; 4 | A1 <<= 4; 5 | A2 <<= 4; 6 | GTE_SetRegister(GTE_CREG_RFC,A0); 7 | GTE_SetRegister(GTE_CREG_GFC,A1); 8 | GTE_SetRegister(GTE_CREG_BFC,A2); 9 | ZZ_JUMPREGISTER_BEGIN(RA); 10 | ZZ_CLOCKCYCLES_JR(8); 11 | ZZ_JUMPREGISTER(0x80017B84,ZZ_17AB0_D4); 12 | ZZ_JUMPREGISTER(0x80017E5C,ZZ_17CE8_174); 13 | ZZ_JUMPREGISTER_END(); 14 | #endif 15 | ZZ_MARK_TARGET(0x8004F260,0x8004F280,ZZ_4F260); 16 | -------------------------------------------------------------------------------- /srczz/zz_164e4.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_164E4: 3 | V0 = EMU_ReadU32(A0 + 8332); //+ 0x208C 4 | EMU_Write32(A0 + 8328,R0); //+ 0x2088 5 | ZZ_JUMPREGISTER_BEGIN(RA); 6 | EMU_Write32(A0 + 8336,V0); //+ 0x2090 7 | ZZ_CLOCKCYCLES_JR(4); 8 | ZZ_JUMPREGISTER(0x80016454,ZZ_1642C_28); 9 | ZZ_JUMPREGISTER(0x80016508,ZZ_164F4_14); 10 | ZZ_JUMPREGISTER(0x8002FBA8,ZZ_2F9D4_1D4); 11 | ZZ_JUMPREGISTER_END(); 12 | #endif 13 | ZZ_MARK_TARGET(0x800164E4,0x800164F4,ZZ_164E4); 14 | -------------------------------------------------------------------------------- /srczz/zz_50018.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_50018: 3 | A0 = 0x80060000; 4 | A0 = EMU_ReadU32(A0 - 5508); //+ 0xFFFFEA7C 5 | V1 = 0xF0FF0000; 6 | V0 = EMU_ReadU32(A0); 7 | V1 |= 0xFFFF; 8 | V0 &= V1; 9 | V1 = 0x20000000; 10 | V0 |= V1; 11 | ZZ_JUMPREGISTER_BEGIN(RA); 12 | EMU_Write32(A0,V0); 13 | ZZ_CLOCKCYCLES_JR(10); 14 | ZZ_JUMPREGISTER(0x8004FD18,ZZ_4FB34_1E4); 15 | ZZ_JUMPREGISTER_END(); 16 | #endif 17 | ZZ_MARK_TARGET(0x80050018,0x80050040,ZZ_50018); 18 | -------------------------------------------------------------------------------- /srczz/zz_50040.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_50040: 3 | A0 = 0x80060000; 4 | A0 = EMU_ReadU32(A0 - 5508); //+ 0xFFFFEA7C 5 | V1 = 0xF0FF0000; 6 | V0 = EMU_ReadU32(A0); 7 | V1 |= 0xFFFF; 8 | V0 &= V1; 9 | V1 = 0x22000000; 10 | V0 |= V1; 11 | ZZ_JUMPREGISTER_BEGIN(RA); 12 | EMU_Write32(A0,V0); 13 | ZZ_CLOCKCYCLES_JR(10); 14 | ZZ_JUMPREGISTER(0x8004FD08,ZZ_4FB34_1D4); 15 | ZZ_JUMPREGISTER_END(); 16 | #endif 17 | ZZ_MARK_TARGET(0x80050040,0x80050068,ZZ_50040); 18 | -------------------------------------------------------------------------------- /src/rcnt.h: -------------------------------------------------------------------------------- 1 | #ifndef H_RCNT_H 2 | #define H_RCNT_H 3 | 4 | #include "common.h" 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | enum 11 | { 12 | RCNT_DOTCLOCK, 13 | RCNT_HBLANK, 14 | RCNT_SYSDIV8, 15 | RCNT__COUNT 16 | }; 17 | 18 | extern uint16_t RCNT_GetValue(int counter); 19 | extern void RCNT_SetMode(int counter,uint16_t mode); 20 | extern void RCNT_SetTarget(int counter,uint16_t mode); 21 | 22 | #ifdef __cplusplus 23 | } 24 | #endif 25 | 26 | #endif 27 | -------------------------------------------------------------------------------- /srczz/zz_18f84.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_18F84: 3 | V0 = A0; 4 | V1 = EMU_ReadU32(V0 + 184); //+ 0xB8 5 | if (V1 == A1) 6 | { 7 | ZZ_CLOCKCYCLES(5,0x80018F9C); 8 | goto ZZ_18F84_18; 9 | } 10 | V0 = R0; 11 | ZZ_CLOCKCYCLES(6,0x80018F9C); 12 | ZZ_18F84_18: 13 | ZZ_JUMPREGISTER_BEGIN(RA); 14 | ZZ_CLOCKCYCLES_JR(2); 15 | ZZ_JUMPREGISTER_END(); 16 | #endif 17 | ZZ_MARK_TARGET(0x80018F84,0x80018F9C,ZZ_18F84); 18 | ZZ_MARK_TARGET(0x80018F9C,0x80018FA4,ZZ_18F84_18); 19 | -------------------------------------------------------------------------------- /srczz/zz_43a54.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_43A54: 3 | A0 = EMU_ReadU32(V1 + 252); //+ 0xFC 4 | A1 = EMU_ReadU32(V1 + 292); //+ 0x124 5 | T8 = EMU_ReadU32(T8 + 24); //+ 0x18 6 | A0 <<= 4; 7 | A1 = A1 - A0; 8 | ZZ_JUMPREGISTER_BEGIN(RA); 9 | EMU_SDivide(A1,T8); 10 | ZZ_CLOCKCYCLES_JR(7); 11 | ZZ_JUMPREGISTER(0x8003E17C,ZZ_3DFAC_1D0); 12 | ZZ_JUMPREGISTER(0x8003F22C,ZZ_3EFAC_280); 13 | ZZ_JUMPREGISTER_END(); 14 | #endif 15 | ZZ_MARK_TARGET(0x80043A54,0x80043A70,ZZ_43A54); 16 | -------------------------------------------------------------------------------- /srczz/zz_43a70.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_43A70: 3 | A0 = EMU_ReadU32(GP + 100); //+ 0x64 4 | A1 = EMU_ReadU32(V1 + 292); //+ 0x124 5 | T8 = EMU_ReadU32(T8 + 24); //+ 0x18 6 | A0 <<= 4; 7 | A1 = A1 - A0; 8 | ZZ_JUMPREGISTER_BEGIN(RA); 9 | EMU_SDivide(A1,T8); 10 | ZZ_CLOCKCYCLES_JR(7); 11 | ZZ_JUMPREGISTER(0x8003E3D8,ZZ_3DFAC_42C); 12 | ZZ_JUMPREGISTER(0x8003F488,ZZ_3EFAC_4DC); 13 | ZZ_JUMPREGISTER_END(); 14 | #endif 15 | ZZ_MARK_TARGET(0x80043A70,0x80043A8C,ZZ_43A70); 16 | -------------------------------------------------------------------------------- /srczz/zz_191b0.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_191B0: 3 | V0 = A0; 4 | V1 = EMU_ReadU32(V0 + 256); //+ 0x100 5 | V1 &= A1; 6 | if (V1) 7 | { 8 | ZZ_CLOCKCYCLES(6,0x800191CC); 9 | goto ZZ_191B0_1C; 10 | } 11 | V0 = R0; 12 | ZZ_CLOCKCYCLES(7,0x800191CC); 13 | ZZ_191B0_1C: 14 | ZZ_JUMPREGISTER_BEGIN(RA); 15 | ZZ_CLOCKCYCLES_JR(2); 16 | ZZ_JUMPREGISTER_END(); 17 | #endif 18 | ZZ_MARK_TARGET(0x800191B0,0x800191CC,ZZ_191B0); 19 | ZZ_MARK_TARGET(0x800191CC,0x800191D4,ZZ_191B0_1C); 20 | -------------------------------------------------------------------------------- /srczz/zz_43a10.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_43A10: 3 | A0 = 0xFF7F0000; 4 | A0 |= 0xFFFF; 5 | T9 &= A0; 6 | ZZ_JUMPREGISTER_BEGIN(RA); 7 | EMU_Write32(GP + 168,T9); //+ 0xA8 8 | ZZ_CLOCKCYCLES_JR(5); 9 | ZZ_JUMPREGISTER(0x8003E60C,ZZ_3DFAC_660); 10 | ZZ_JUMPREGISTER(0x8003F6BC,ZZ_3EFAC_710); 11 | ZZ_JUMPREGISTER(0x8004041C,ZZ_3FFAC_470); 12 | ZZ_JUMPREGISTER(0x80041A64,ZZ_41A1C_48); 13 | ZZ_JUMPREGISTER_END(); 14 | #endif 15 | ZZ_MARK_TARGET(0x80043A10,0x80043A24,ZZ_43A10); 16 | -------------------------------------------------------------------------------- /srczz/zz_4f060.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4F060: 3 | T0 = EMU_ReadU32(A1); 4 | T1 = EMU_ReadU32(A1 + 4); //+ 0x4 5 | T2 = EMU_ReadU32(A1 + 8); //+ 0x8 6 | EMU_Write32(A0 + 20,T0); //+ 0x14 7 | EMU_Write32(A0 + 24,T1); //+ 0x18 8 | EMU_Write32(A0 + 28,T2); //+ 0x1C 9 | V0 = A0; 10 | ZZ_JUMPREGISTER_BEGIN(RA); 11 | ZZ_CLOCKCYCLES_JR(9); 12 | ZZ_JUMPREGISTER(0x80017E94,ZZ_17CE8_1AC); 13 | ZZ_JUMPREGISTER_END(); 14 | #endif 15 | ZZ_MARK_TARGET(0x8004F060,0x8004F084,ZZ_4F060); 16 | -------------------------------------------------------------------------------- /srcemu/stdint.h: -------------------------------------------------------------------------------- 1 | #ifndef __STDINT_H__ 2 | #define __STDINT_H__ 3 | 4 | // MSVC doesn't have this header 5 | // So, I have to write it myself 6 | 7 | typedef signed char int8_t; 8 | typedef unsigned char uint8_t; 9 | typedef signed short int16_t; 10 | typedef unsigned short uint16_t; 11 | typedef signed int int32_t; 12 | typedef unsigned int uint32_t; 13 | typedef signed long long int64_t; 14 | typedef unsigned long long uint64_t; 15 | 16 | #endif 17 | -------------------------------------------------------------------------------- /srczz/zz_4b9a8.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4B9A8: 3 | V0 = 5; 4 | EMU_Write8(A0 + 3,V0); //+ 0x3 5 | V0 = 40; 6 | ZZ_JUMPREGISTER_BEGIN(RA); 7 | EMU_Write8(A0 + 7,V0); //+ 0x7 8 | ZZ_CLOCKCYCLES_JR(5); 9 | ZZ_JUMPREGISTER(0x80016CF0,ZZ_16C38_B8); 10 | ZZ_JUMPREGISTER(0x80016EA4,ZZ_16D84_120); 11 | ZZ_JUMPREGISTER(0x80016F1C,ZZ_16D84_198); 12 | ZZ_JUMPREGISTER(0x80016F8C,ZZ_16D84_208); 13 | ZZ_JUMPREGISTER_END(); 14 | #endif 15 | ZZ_MARK_TARGET(0x8004B9A8,0x8004B9BC,ZZ_4B9A8); 16 | -------------------------------------------------------------------------------- /srczz/zz_4e374.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4E374: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | A3 = A2; 6 | RA = 0x8004E388; //ZZ_4E374_14 7 | A2 = R0; 8 | ZZ_CLOCKCYCLES(5,0x8004E398); 9 | goto ZZ_4E398; 10 | ZZ_4E374_14: 11 | RA = EMU_ReadU32(SP + 16); //+ 0x10 12 | SP += 24; 13 | ZZ_JUMPREGISTER_BEGIN(RA); 14 | ZZ_CLOCKCYCLES_JR(4); 15 | ZZ_JUMPREGISTER_END(); 16 | #endif 17 | ZZ_MARK_TARGET(0x8004E374,0x8004E388,ZZ_4E374); 18 | ZZ_MARK_TARGET(0x8004E388,0x8004E398,ZZ_4E374_14); 19 | -------------------------------------------------------------------------------- /srczz/zz_4b728.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4B728: 3 | V0 = A0 & 0x3; 4 | V0 <<= 7; 5 | A1 &= 0x3; 6 | A1 <<= 5; 7 | V0 |= A1; 8 | V1 = A3 & 0x100; 9 | V1 = (int32_t)V1 >> 4; 10 | V0 |= V1; 11 | A2 &= 0x3FF; 12 | A2 = (int32_t)A2 >> 6; 13 | V0 |= A2; 14 | A3 &= 0x200; 15 | A3 <<= 2; 16 | ZZ_JUMPREGISTER_BEGIN(RA); 17 | V0 |= A3; 18 | ZZ_CLOCKCYCLES_JR(15); 19 | ZZ_JUMPREGISTER(0x80016D40,ZZ_16C38_108); 20 | ZZ_JUMPREGISTER_END(); 21 | #endif 22 | ZZ_MARK_TARGET(0x8004B728,0x8004B764,ZZ_4B728); 23 | -------------------------------------------------------------------------------- /srczz/zz_43240.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_43240: 3 | T8 = EMU_ReadU32(A0); 4 | T9 = EMU_ReadU32(A0 + 4); //+ 0x4 5 | GTE_SetRegister(GTE_CREG_RT11_RT12,T8); 6 | GTE_SetRegister(GTE_CREG_RT13_RT21,T9); 7 | T8 = EMU_ReadU32(A0 + 8); //+ 0x8 8 | T9 = EMU_ReadU32(A0 + 12); //+ 0xC 9 | A0 = EMU_ReadU32(A0 + 16); //+ 0x10 10 | GTE_SetRegister(GTE_CREG_RT22_RT23,T8); 11 | GTE_SetRegister(GTE_CREG_RT31_RT32,T9); 12 | GTE_SetRegister(GTE_CREG_RT33_NONE,A0); 13 | #endif 14 | ZZ_MARK_TARGET(0x80043240,0x80043268,ZZ_43240); 15 | -------------------------------------------------------------------------------- /srczz/zz_46cd8.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_46CD8: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | RA = 0x80046CE8; //ZZ_46CD8_10 6 | ZZ_CLOCKCYCLES(4,0x80048330); 7 | goto ZZ_48330; 8 | ZZ_46CD8_10: 9 | RA = EMU_ReadU32(SP + 16); //+ 0x10 10 | SP += 24; 11 | ZZ_JUMPREGISTER_BEGIN(RA); 12 | ZZ_CLOCKCYCLES_JR(4); 13 | ZZ_JUMPREGISTER(0x8004906C,ZZ_48F5C_110); 14 | ZZ_JUMPREGISTER_END(); 15 | #endif 16 | ZZ_MARK_TARGET(0x80046CD8,0x80046CE8,ZZ_46CD8); 17 | ZZ_MARK_TARGET(0x80046CE8,0x80046CF8,ZZ_46CD8_10); 18 | -------------------------------------------------------------------------------- /srczz/zz_46d98.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_46D98: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | RA = 0x80046DA8; //ZZ_46D98_10 6 | ZZ_CLOCKCYCLES(4,0x80047BC0); 7 | goto ZZ_47BC0; 8 | ZZ_46D98_10: 9 | RA = EMU_ReadU32(SP + 16); //+ 0x10 10 | SP += 24; 11 | ZZ_JUMPREGISTER_BEGIN(RA); 12 | ZZ_CLOCKCYCLES_JR(4); 13 | ZZ_JUMPREGISTER(0x800493B8,ZZ_49310_A8); 14 | ZZ_JUMPREGISTER_END(); 15 | #endif 16 | ZZ_MARK_TARGET(0x80046D98,0x80046DA8,ZZ_46D98); 17 | ZZ_MARK_TARGET(0x80046DA8,0x80046DB8,ZZ_46D98_10); 18 | -------------------------------------------------------------------------------- /srczz/zz_46bb4.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_46BB4: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | A0 = 0xF0000000; 6 | A0 |= 0x3; 7 | RA = 0x80046BCC; //ZZ_46BB4_18 8 | A1 = 32; 9 | ZZ_CLOCKCYCLES(6,0x80049F54); 10 | goto ZZ_49F54; 11 | ZZ_46BB4_18: 12 | RA = EMU_ReadU32(SP + 16); //+ 0x10 13 | SP += 24; 14 | ZZ_JUMPREGISTER_BEGIN(RA); 15 | ZZ_CLOCKCYCLES_JR(4); 16 | ZZ_JUMPREGISTER_END(); 17 | #endif 18 | ZZ_MARK_TARGET(0x80046BB4,0x80046BCC,ZZ_46BB4); 19 | ZZ_MARK_TARGET(0x80046BCC,0x80046BDC,ZZ_46BB4_18); 20 | -------------------------------------------------------------------------------- /srczz/zz_46c04.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_46C04: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | A0 = 0xF0000000; 6 | A0 |= 0x3; 7 | RA = 0x80046C1C; //ZZ_46C04_18 8 | A1 = 64; 9 | ZZ_CLOCKCYCLES(6,0x80049F54); 10 | goto ZZ_49F54; 11 | ZZ_46C04_18: 12 | RA = EMU_ReadU32(SP + 16); //+ 0x10 13 | SP += 24; 14 | ZZ_JUMPREGISTER_BEGIN(RA); 15 | ZZ_CLOCKCYCLES_JR(4); 16 | ZZ_JUMPREGISTER_END(); 17 | #endif 18 | ZZ_MARK_TARGET(0x80046C04,0x80046C1C,ZZ_46C04); 19 | ZZ_MARK_TARGET(0x80046C1C,0x80046C2C,ZZ_46C04_18); 20 | -------------------------------------------------------------------------------- /srczz/zz_46db8.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_46DB8: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU32(V0 - 13724); //+ 0xFFFFCA64 5 | AT = 0x80060000; 6 | EMU_Write32(AT - 13724,A0); //+ 0xFFFFCA64 7 | ZZ_JUMPREGISTER_BEGIN(RA); 8 | ZZ_CLOCKCYCLES_JR(6); 9 | ZZ_JUMPREGISTER(0x80046B50,ZZ_46B1C_34); 10 | ZZ_JUMPREGISTER(0x80048F78,ZZ_48F5C_1C); 11 | ZZ_JUMPREGISTER(0x80049284,ZZ_4920C_78); 12 | ZZ_JUMPREGISTER(0x80048DD4,ZZ_48B90_244); 13 | ZZ_JUMPREGISTER_END(); 14 | #endif 15 | ZZ_MARK_TARGET(0x80046DB8,0x80046DD0,ZZ_46DB8); 16 | -------------------------------------------------------------------------------- /src/gool.h: -------------------------------------------------------------------------------- 1 | #ifndef H_GOOL_H 2 | #define H_GOOL_H 3 | 4 | #include "common.h" 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | enum 11 | { 12 | GOOL_LANGUAGE_GOOL, 13 | GOOL_LANGUAGE_MIPS, 14 | GOOL_LANGUAGE__COUNT 15 | }; 16 | 17 | struct goolenv 18 | { 19 | uint32_t oldpc; 20 | uint32_t pc; 21 | uint32_t pcfar; 22 | int language; 23 | int languagefar; 24 | }; 25 | 26 | typedef void (*goolexechandler_t)(struct goolenv *env,uint32_t instruction); 27 | 28 | #ifdef __cplusplus 29 | } 30 | #endif 31 | 32 | #endif 33 | -------------------------------------------------------------------------------- /srczz/zz_4f220.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4F220: 3 | T0 = EMU_ReadU32(A0 + 20); //+ 0x14 4 | T1 = EMU_ReadU32(A0 + 24); //+ 0x18 5 | T2 = EMU_ReadU32(A0 + 28); //+ 0x1C 6 | GTE_SetRegister(GTE_CREG_TRX,T0); 7 | GTE_SetRegister(GTE_CREG_TRY,T1); 8 | GTE_SetRegister(GTE_CREG_TRZ,T2); 9 | ZZ_JUMPREGISTER_BEGIN(RA); 10 | ZZ_CLOCKCYCLES_JR(8); 11 | ZZ_JUMPREGISTER(0x8001EFF4,ZZ_1EFA8_4C); 12 | ZZ_JUMPREGISTER(0x8001EED8,ZZ_1EE74_64); 13 | ZZ_JUMPREGISTER_END(); 14 | #endif 15 | ZZ_MARK_TARGET(0x8004F220,0x8004F240,ZZ_4F220); 16 | -------------------------------------------------------------------------------- /srczz/zz_243fc.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_243FC: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | RA = 0x8002440C; //ZZ_243FC_10 6 | ZZ_CLOCKCYCLES(4,0x8002441C); 7 | goto ZZ_2441C; 8 | ZZ_243FC_10: 9 | RA = EMU_ReadU32(SP + 16); //+ 0x10 10 | V0 = -255; 11 | ZZ_JUMPREGISTER_BEGIN(RA); 12 | SP += 24; 13 | ZZ_CLOCKCYCLES_JR(4); 14 | ZZ_JUMPREGISTER(0x80014FC8,ZZ_14D6C_25C); 15 | ZZ_JUMPREGISTER_END(); 16 | #endif 17 | ZZ_MARK_TARGET(0x800243FC,0x8002440C,ZZ_243FC); 18 | ZZ_MARK_TARGET(0x8002440C,0x8002441C,ZZ_243FC_10); 19 | -------------------------------------------------------------------------------- /srczz/zz_36648.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_36648: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | RA = 0x80036658; //ZZ_36648_10 6 | ZZ_CLOCKCYCLES(4,0x8005B358); 7 | goto ZZ_5B358; 8 | ZZ_36648_10: 9 | RA = EMU_ReadU32(SP + 16); //+ 0x10 10 | V0 = R0; 11 | ZZ_JUMPREGISTER_BEGIN(RA); 12 | SP += 24; 13 | ZZ_CLOCKCYCLES_JR(4); 14 | ZZ_JUMPREGISTER(0x800158F8,ZZ_158C4_34); 15 | ZZ_JUMPREGISTER_END(); 16 | #endif 17 | ZZ_MARK_TARGET(0x80036648,0x80036658,ZZ_36648); 18 | ZZ_MARK_TARGET(0x80036658,0x80036668,ZZ_36648_10); 19 | -------------------------------------------------------------------------------- /srczz/zz_52ff4.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_52FF4: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | RA = 0x80053004; //ZZ_52FF4_10 6 | A0 = R0; 7 | ZZ_CLOCKCYCLES(4,0x800501A0); 8 | goto ZZ_501A0; 9 | ZZ_52FF4_10: 10 | RA = EMU_ReadU32(SP + 16); //+ 0x10 11 | SP += 24; 12 | ZZ_JUMPREGISTER_BEGIN(RA); 13 | ZZ_CLOCKCYCLES_JR(4); 14 | ZZ_JUMPREGISTER(0x80052FDC,ZZ_52FC4_18); 15 | ZZ_JUMPREGISTER_END(); 16 | #endif 17 | ZZ_MARK_TARGET(0x80052FF4,0x80053004,ZZ_52FF4); 18 | ZZ_MARK_TARGET(0x80053004,0x80053014,ZZ_52FF4_10); 19 | -------------------------------------------------------------------------------- /srczz/zz_550cc.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_550CC: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | RA = 0x800550DC; //ZZ_550CC_10 6 | A0 = 1; 7 | ZZ_CLOCKCYCLES(4,0x80054E64); 8 | goto ZZ_54E64; 9 | ZZ_550CC_10: 10 | RA = EMU_ReadU32(SP + 16); //+ 0x10 11 | SP += 24; 12 | ZZ_JUMPREGISTER_BEGIN(RA); 13 | ZZ_CLOCKCYCLES_JR(4); 14 | ZZ_JUMPREGISTER(0x8003444C,ZZ_34204_248); 15 | ZZ_JUMPREGISTER_END(); 16 | #endif 17 | ZZ_MARK_TARGET(0x800550CC,0x800550DC,ZZ_550CC); 18 | ZZ_MARK_TARGET(0x800550DC,0x800550EC,ZZ_550CC_10); 19 | -------------------------------------------------------------------------------- /src/cdr.h: -------------------------------------------------------------------------------- 1 | #ifndef H_CDR_H 2 | #define H_CDR_H 3 | 4 | #include "common.h" 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | extern uint8_t CDR_GetStatus(void); 11 | extern void CDR_SetMode(int mode); 12 | 13 | extern uint8_t CDR_Read(void); 14 | extern uint8_t CDR_ReadResponse(void); 15 | 16 | extern uint8_t CDR_Read3(void); 17 | 18 | extern void CDR_Write1(uint8_t value); 19 | extern void CDR_Write2(uint8_t value); 20 | extern void CDR_Write3(uint8_t value); 21 | 22 | #ifdef __cplusplus 23 | } 24 | #endif 25 | 26 | #endif 27 | -------------------------------------------------------------------------------- /srczz/zz_36480.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_36480: 3 | V0 = EMU_ReadU32(GP + 232); //+ 0xE8 4 | V0 = EMU_ReadU32(V0); 5 | ZZ_JUMPREGISTER_BEGIN(RA); 6 | ZZ_CLOCKCYCLES_JR(5); 7 | ZZ_JUMPREGISTER(0x800368DC,ZZ_368CC_10); 8 | ZZ_JUMPREGISTER(0x800368EC,ZZ_368CC_20); 9 | ZZ_JUMPREGISTER(0x80034928,ZZ_348EC_3C); 10 | ZZ_JUMPREGISTER(0x80034954,ZZ_348EC_68); 11 | ZZ_JUMPREGISTER(0x80034940,ZZ_348EC_54); 12 | ZZ_JUMPREGISTER(0x800349B4,ZZ_348EC_C8); 13 | ZZ_JUMPREGISTER_END(); 14 | #endif 15 | ZZ_MARK_TARGET(0x80036480,0x80036494,ZZ_36480); 16 | -------------------------------------------------------------------------------- /srczz/zz_50300.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_50300: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | A1 = A0; 6 | RA = 0x80050314; //ZZ_50300_14 7 | A0 = 4; 8 | ZZ_CLOCKCYCLES(5,0x8004A970); 9 | goto ZZ_4A970; 10 | ZZ_50300_14: 11 | RA = EMU_ReadU32(SP + 16); //+ 0x10 12 | SP += 24; 13 | ZZ_JUMPREGISTER_BEGIN(RA); 14 | ZZ_CLOCKCYCLES_JR(4); 15 | ZZ_JUMPREGISTER(0x800502B8,ZZ_50288_30); 16 | ZZ_JUMPREGISTER_END(); 17 | #endif 18 | ZZ_MARK_TARGET(0x80050300,0x80050314,ZZ_50300); 19 | ZZ_MARK_TARGET(0x80050314,0x80050324,ZZ_50300_14); 20 | -------------------------------------------------------------------------------- /srczz/zz_3455c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_3455C: 3 | V0 = EMU_ReadU32(GP + 544); //+ 0x220 4 | if (V0) 5 | { 6 | V0 = 0x1; 7 | ZZ_CLOCKCYCLES(4,0x80034570); 8 | goto ZZ_3455C_14; 9 | } 10 | V0 = 0x1; 11 | EMU_Write32(GP + 544,V0); //+ 0x220 12 | ZZ_CLOCKCYCLES(5,0x80034570); 13 | ZZ_3455C_14: 14 | ZZ_JUMPREGISTER_BEGIN(RA); 15 | ZZ_CLOCKCYCLES_JR(2); 16 | ZZ_JUMPREGISTER(0x80020C70,ZZ_20BF4_7C); 17 | ZZ_JUMPREGISTER_END(); 18 | #endif 19 | ZZ_MARK_TARGET(0x8003455C,0x80034570,ZZ_3455C); 20 | ZZ_MARK_TARGET(0x80034570,0x80034578,ZZ_3455C_14); 21 | -------------------------------------------------------------------------------- /srczz/zz_43a24.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_43A24: 3 | A0 = 0x800000; 4 | T9 |= A0; 5 | ZZ_JUMPREGISTER_BEGIN(RA); 6 | EMU_Write32(GP + 168,T9); //+ 0xA8 7 | ZZ_CLOCKCYCLES_JR(4); 8 | ZZ_JUMPREGISTER(0x8003E3F0,ZZ_3DFAC_444); 9 | ZZ_JUMPREGISTER(0x8003F4A0,ZZ_3EFAC_4F4); 10 | ZZ_JUMPREGISTER(0x800401E4,ZZ_3FFAC_238); 11 | ZZ_JUMPREGISTER(0x80041294,ZZ_40FAC_2E8); 12 | ZZ_JUMPREGISTER(0x8003E1AC,ZZ_3DFAC_200); 13 | ZZ_JUMPREGISTER(0x8003F25C,ZZ_3EFAC_2B0); 14 | ZZ_JUMPREGISTER_END(); 15 | #endif 16 | ZZ_MARK_TARGET(0x80043A24,0x80043A34,ZZ_43A24); 17 | -------------------------------------------------------------------------------- /srczz/zz_35dc0.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_35DC0: 3 | V0 = EMU_ReadU32(GP + 232); //+ 0xE8 4 | EMU_Write32(V0 + 20,R0); //+ 0x14 5 | EMU_Write32(V0 + 16,A0); //+ 0x10 6 | ZZ_JUMPREGISTER_BEGIN(RA); 7 | V0 = R0; 8 | ZZ_CLOCKCYCLES_JR(6); 9 | ZZ_JUMPREGISTER(0x80036918,ZZ_368CC_4C); 10 | ZZ_JUMPREGISTER(0x80036860,ZZ_367E0_80); 11 | ZZ_JUMPREGISTER(0x80036350,ZZ_3631C_34); 12 | ZZ_JUMPREGISTER(0x80034B0C,ZZ_34A0C_100); 13 | ZZ_JUMPREGISTER(0x80034CD8,ZZ_34BCC_10C); 14 | ZZ_JUMPREGISTER_END(); 15 | #endif 16 | ZZ_MARK_TARGET(0x80035DC0,0x80035DD8,ZZ_35DC0); 17 | -------------------------------------------------------------------------------- /srczz/zz_47214.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_47214: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | RA = 0x80047224; //ZZ_47214_10 6 | ZZ_CLOCKCYCLES(4,0x80048740); 7 | goto ZZ_48740; 8 | ZZ_47214_10: 9 | RA = EMU_ReadU32(SP + 16); //+ 0x10 10 | SP += 24; 11 | ZZ_JUMPREGISTER_BEGIN(RA); 12 | ZZ_CLOCKCYCLES_JR(4); 13 | ZZ_JUMPREGISTER(0x80012FC8,ZZ_12F94_34); 14 | ZZ_JUMPREGISTER(0x80048C14,ZZ_48B90_84); 15 | ZZ_JUMPREGISTER_END(); 16 | #endif 17 | ZZ_MARK_TARGET(0x80047214,0x80047224,ZZ_47214); 18 | ZZ_MARK_TARGET(0x80047224,0x80047234,ZZ_47214_10); 19 | -------------------------------------------------------------------------------- /srczz/zz_46dd0.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_46DD0: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU32(V0 - 13720); //+ 0xFFFFCA68 5 | AT = 0x80060000; 6 | EMU_Write32(AT - 13720,A0); //+ 0xFFFFCA68 7 | ZZ_JUMPREGISTER_BEGIN(RA); 8 | ZZ_CLOCKCYCLES_JR(6); 9 | ZZ_JUMPREGISTER(0x80046B60,ZZ_46B1C_44); 10 | ZZ_JUMPREGISTER(0x80048F80,ZZ_48F5C_24); 11 | ZZ_JUMPREGISTER(0x80049298,ZZ_4920C_8C); 12 | ZZ_JUMPREGISTER(0x800490E4,ZZ_48F5C_188); 13 | ZZ_JUMPREGISTER(0x80048DE4,ZZ_48B90_254); 14 | ZZ_JUMPREGISTER_END(); 15 | #endif 16 | ZZ_MARK_TARGET(0x80046DD0,0x80046DE8,ZZ_46DD0); 17 | -------------------------------------------------------------------------------- /srczz/zz_1144c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_1144C: 3 | AT = 0x80060000; 4 | EMU_Write32(AT - 2756,A0); //+ 0xFFFFF53C 5 | EMU_Write32(A0,R0); 6 | V0 = A1 >> 2; 7 | V0 <<= 2; 8 | A0 += V0; 9 | A0 += 4; 10 | AT = 0x80060000; 11 | EMU_Write32(AT - 2740,A0); //+ 0xFFFFF54C 12 | A1 -= 4; 13 | AT = 0x80060000; 14 | EMU_Write32(AT - 2748,A1); //+ 0xFFFFF544 15 | AT = 0x80060000; 16 | EMU_Write32(AT - 2732,R0); //+ 0xFFFFF554 17 | ZZ_JUMPREGISTER_BEGIN(RA); 18 | ZZ_CLOCKCYCLES_JR(16); 19 | ZZ_JUMPREGISTER_END(); 20 | #endif 21 | ZZ_MARK_TARGET(0x8001144C,0x8001148C,ZZ_1144C); 22 | -------------------------------------------------------------------------------- /srczz/zz_19f40.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_19F40: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | RA = 0x80019F50; //ZZ_19F40_10 6 | A1 = 0x1; 7 | ZZ_CLOCKCYCLES(4,0x80019CF4); 8 | goto ZZ_19CF4; 9 | ZZ_19F40_10: 10 | RA = EMU_ReadU32(SP + 16); //+ 0x10 11 | SP += 24; 12 | ZZ_JUMPREGISTER_BEGIN(RA); 13 | ZZ_CLOCKCYCLES_JR(4); 14 | ZZ_JUMPREGISTER(0x80019A14,ZZ_19928_EC); 15 | ZZ_JUMPREGISTER(0x80019600,ZZ_191D4_42C); 16 | ZZ_JUMPREGISTER_END(); 17 | #endif 18 | ZZ_MARK_TARGET(0x80019F40,0x80019F50,ZZ_19F40); 19 | ZZ_MARK_TARGET(0x80019F50,0x80019F60,ZZ_19F40_10); 20 | -------------------------------------------------------------------------------- /srczz/zz_43960.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_43960: 3 | S4 = EMU_ReadU32(SP + 40); //+ 0x28 4 | S7 = EMU_ReadU32(V1 + 20); //+ 0x14 5 | T9 = EMU_ReadU32(S4); 6 | A0 = EMU_ReadU32(S4 + 4); //+ 0x4 7 | EMU_Write32(V1 + 280,T9); //+ 0x118 8 | EMU_Write32(V1 + 284,A0); //+ 0x11C 9 | T1 = 0x3FC0000; 10 | T1 |= 0x3FC; 11 | T2 = 0xFFFE0000; 12 | ZZ_JUMPREGISTER_BEGIN(T8); 13 | T2 |= 0xFFFF; 14 | ZZ_CLOCKCYCLES_JR(11); 15 | // UNIMPLEMENTED INDIRECT JUMP (T8,80043984) 16 | // PC IS 80043984 17 | ZZ_JUMPREGISTER_END(); 18 | #endif 19 | ZZ_MARK_TARGET(0x80043960,0x8004398C,ZZ_43960); 20 | -------------------------------------------------------------------------------- /srczz/zz_471b0.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_471B0: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | RA = 0x800471C0; //ZZ_471B0_10 6 | ZZ_CLOCKCYCLES(4,0x800488AC); 7 | goto ZZ_488AC; 8 | ZZ_471B0_10: 9 | RA = EMU_ReadU32(SP + 16); //+ 0x10 10 | V0 = V0 < 1; 11 | ZZ_JUMPREGISTER_BEGIN(RA); 12 | SP += 24; 13 | ZZ_CLOCKCYCLES_JR(4); 14 | ZZ_JUMPREGISTER(0x80048C34,ZZ_48B90_A4); 15 | ZZ_JUMPREGISTER(0x80048CC4,ZZ_48B90_134); 16 | ZZ_JUMPREGISTER_END(); 17 | #endif 18 | ZZ_MARK_TARGET(0x800471B0,0x800471C0,ZZ_471B0); 19 | ZZ_MARK_TARGET(0x800471C0,0x800471D0,ZZ_471B0_10); 20 | -------------------------------------------------------------------------------- /srczz/zz_471d0.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_471D0: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | RA = 0x800471E0; //ZZ_471D0_10 6 | ZZ_CLOCKCYCLES(4,0x800489AC); 7 | goto ZZ_489AC; 8 | ZZ_471D0_10: 9 | RA = EMU_ReadU32(SP + 16); //+ 0x10 10 | V0 = V0 < 1; 11 | ZZ_JUMPREGISTER_BEGIN(RA); 12 | SP += 24; 13 | ZZ_CLOCKCYCLES_JR(4); 14 | ZZ_JUMPREGISTER(0x80048C0C,ZZ_48B90_7C); 15 | ZZ_JUMPREGISTER(0x80048CA4,ZZ_48B90_114); 16 | ZZ_JUMPREGISTER_END(); 17 | #endif 18 | ZZ_MARK_TARGET(0x800471D0,0x800471E0,ZZ_471D0); 19 | ZZ_MARK_TARGET(0x800471E0,0x800471F0,ZZ_471D0_10); 20 | -------------------------------------------------------------------------------- /srczz/zz_31974.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_31974: 3 | V0 = A0 - A1; 4 | if ((int32_t)V0 >= 0) 5 | { 6 | ZZ_CLOCKCYCLES(3,0x80031984); 7 | goto ZZ_31974_10; 8 | } 9 | V0 = A1 - A0; 10 | ZZ_CLOCKCYCLES(4,0x80031984); 11 | ZZ_31974_10: 12 | ZZ_JUMPREGISTER_BEGIN(RA); 13 | ZZ_CLOCKCYCLES_JR(2); 14 | ZZ_JUMPREGISTER(0x80019378,ZZ_191D4_1A4); 15 | ZZ_JUMPREGISTER(0x80019394,ZZ_191D4_1C0); 16 | ZZ_JUMPREGISTER(0x800193B0,ZZ_191D4_1DC); 17 | ZZ_JUMPREGISTER_END(); 18 | #endif 19 | ZZ_MARK_TARGET(0x80031974,0x80031984,ZZ_31974); 20 | ZZ_MARK_TARGET(0x80031984,0x8003198C,ZZ_31974_10); 21 | -------------------------------------------------------------------------------- /srczz/zz_1214c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_1214C: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | A2 = R0; 6 | RA = 0x80012160; //ZZ_1214C_14 7 | A3 = R0; 8 | ZZ_CLOCKCYCLES(5,0x80012170); 9 | goto ZZ_12170; 10 | ZZ_1214C_14: 11 | RA = EMU_ReadU32(SP + 16); //+ 0x10 12 | SP += 24; 13 | ZZ_JUMPREGISTER_BEGIN(RA); 14 | ZZ_CLOCKCYCLES_JR(4); 15 | ZZ_JUMPREGISTER(0x80014E08,ZZ_14D6C_9C); 16 | ZZ_JUMPREGISTER(0x80014F00,ZZ_14D6C_194); 17 | ZZ_JUMPREGISTER_END(); 18 | #endif 19 | ZZ_MARK_TARGET(0x8001214C,0x80012160,ZZ_1214C); 20 | ZZ_MARK_TARGET(0x80012160,0x80012170,ZZ_1214C_14); 21 | -------------------------------------------------------------------------------- /srczz/zz_1828c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_1828C: 3 | V0 = 0x1000; 4 | EMU_Write32(A0 + 12,R0); //+ 0xC 5 | EMU_Write32(A0 + 16,R0); //+ 0x10 6 | EMU_Write32(A0 + 20,R0); //+ 0x14 7 | EMU_Write32(A0,R0); 8 | EMU_Write32(A0 + 4,R0); //+ 0x4 9 | EMU_Write32(A0 + 8,R0); //+ 0x8 10 | EMU_Write32(A0 + 24,V0); //+ 0x18 11 | EMU_Write32(A0 + 28,V0); //+ 0x1C 12 | ZZ_JUMPREGISTER_BEGIN(RA); 13 | EMU_Write32(A0 + 32,V0); //+ 0x20 14 | ZZ_CLOCKCYCLES_JR(11); 15 | ZZ_JUMPREGISTER(0x80017B94,ZZ_17AB0_E4); 16 | ZZ_JUMPREGISTER_END(); 17 | #endif 18 | ZZ_MARK_TARGET(0x8001828C,0x800182B8,ZZ_1828C); 19 | -------------------------------------------------------------------------------- /src/irq.h: -------------------------------------------------------------------------------- 1 | #ifndef H_IRQ_H 2 | #define H_IRQ_H 3 | 4 | #include "common.h" 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | enum 11 | { 12 | IRQ_VBLANK, 13 | IRQ_GPU, 14 | IRQ_CDR, 15 | IRQ_DMA, 16 | IRQ_TMR0, 17 | IRQ_TMR1, 18 | IRQ_TMR2, 19 | IRQ_PAD, 20 | IRQ_SIO, 21 | IRQ_SPU, 22 | IRQ_PAD_SPECIAL, 23 | IRQ__COUNT 24 | }; 25 | 26 | extern uint16_t IRQ_GetStatus(void); 27 | extern void IRQ_AcknowledgeBits(uint16_t value); 28 | extern uint16_t IRQ_GetMask(void); 29 | extern void IRQ_SetMask(uint16_t value); 30 | 31 | #ifdef __cplusplus 32 | } 33 | #endif 34 | 35 | #endif 36 | -------------------------------------------------------------------------------- /srczz/zz_50e70.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_50E70: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | A2 = 204; 6 | RA = 0x80050E84; //ZZ_50E70_14 7 | A3 = 205; 8 | ZZ_CLOCKCYCLES(5,0x80050EA0); 9 | goto ZZ_50EA0; 10 | ZZ_50E70_14: 11 | RA = EMU_ReadU32(SP + 16); //+ 0x10 12 | SP += 24; 13 | ZZ_JUMPREGISTER_BEGIN(RA); 14 | ZZ_CLOCKCYCLES_JR(4); 15 | ZZ_JUMPREGISTER(0x800331BC,ZZ_32E88_334); 16 | ZZ_JUMPREGISTER(0x800576B0,ZZ_572C0_3F0); 17 | ZZ_JUMPREGISTER_END(); 18 | #endif 19 | ZZ_MARK_TARGET(0x80050E70,0x80050E84,ZZ_50E70); 20 | ZZ_MARK_TARGET(0x80050E84,0x80050E94,ZZ_50E70_14); 21 | -------------------------------------------------------------------------------- /srczz/zz_529d0.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_529D0: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | A0 <<= 16; 6 | RA = 0x800529E4; //ZZ_529D0_14 7 | A0 = (int32_t)A0 >> 16; 8 | ZZ_CLOCKCYCLES(5,0x80052830); 9 | goto ZZ_52830; 10 | ZZ_529D0_14: 11 | RA = EMU_ReadU32(SP + 16); //+ 0x10 12 | SP += 24; 13 | ZZ_JUMPREGISTER_BEGIN(RA); 14 | ZZ_CLOCKCYCLES_JR(4); 15 | ZZ_JUMPREGISTER(0x8003479C,ZZ_34770_2C); 16 | ZZ_JUMPREGISTER(0x80034298,ZZ_34204_94); 17 | ZZ_JUMPREGISTER_END(); 18 | #endif 19 | ZZ_MARK_TARGET(0x800529D0,0x800529E4,ZZ_529D0); 20 | ZZ_MARK_TARGET(0x800529E4,0x800529F4,ZZ_529D0_14); 21 | -------------------------------------------------------------------------------- /srczz/zz_54b6c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_54B6C: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | A0 <<= 16; 6 | A1 <<= 16; 7 | A0 = (int32_t)A0 >> 16; 8 | RA = 0x80054B88; //ZZ_54B6C_1C 9 | A1 = (int32_t)A1 >> 16; 10 | ZZ_CLOCKCYCLES(7,0x80054A74); 11 | goto ZZ_54A74; 12 | ZZ_54B6C_1C: 13 | RA = EMU_ReadU32(SP + 16); //+ 0x10 14 | SP += 24; 15 | ZZ_JUMPREGISTER_BEGIN(RA); 16 | ZZ_CLOCKCYCLES_JR(4); 17 | ZZ_JUMPREGISTER(0x8003486C,ZZ_347D4_98); 18 | ZZ_JUMPREGISTER_END(); 19 | #endif 20 | ZZ_MARK_TARGET(0x80054B6C,0x80054B88,ZZ_54B6C); 21 | ZZ_MARK_TARGET(0x80054B88,0x80054B98,ZZ_54B6C_1C); 22 | -------------------------------------------------------------------------------- /srczz/zz_54ccc.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_54CCC: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | A0 <<= 16; 6 | A1 <<= 16; 7 | A0 = (int32_t)A0 >> 16; 8 | RA = 0x80054CE8; //ZZ_54CCC_1C 9 | A1 = (int32_t)A1 >> 16; 10 | ZZ_CLOCKCYCLES(7,0x80054C08); 11 | goto ZZ_54C08; 12 | ZZ_54CCC_1C: 13 | RA = EMU_ReadU32(SP + 16); //+ 0x10 14 | SP += 24; 15 | ZZ_JUMPREGISTER_BEGIN(RA); 16 | ZZ_CLOCKCYCLES_JR(4); 17 | ZZ_JUMPREGISTER(0x80034888,ZZ_347D4_B4); 18 | ZZ_JUMPREGISTER_END(); 19 | #endif 20 | ZZ_MARK_TARGET(0x80054CCC,0x80054CE8,ZZ_54CCC); 21 | ZZ_MARK_TARGET(0x80054CE8,0x80054CF8,ZZ_54CCC_1C); 22 | -------------------------------------------------------------------------------- /srczz/zz_55b78.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_55B78: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | A0 <<= 16; 6 | A1 <<= 16; 7 | A0 = (int32_t)A0 >> 16; 8 | RA = 0x80055B94; //ZZ_55B78_1C 9 | A1 = (int32_t)A1 >> 16; 10 | ZZ_CLOCKCYCLES(7,0x80055BA4); 11 | goto ZZ_55BA4; 12 | ZZ_55B78_1C: 13 | RA = EMU_ReadU32(SP + 16); //+ 0x10 14 | SP += 24; 15 | ZZ_JUMPREGISTER_BEGIN(RA); 16 | ZZ_CLOCKCYCLES_JR(4); 17 | ZZ_JUMPREGISTER(0x80055274,ZZ_5519C_D8); 18 | ZZ_JUMPREGISTER_END(); 19 | #endif 20 | ZZ_MARK_TARGET(0x80055B78,0x80055B94,ZZ_55B78); 21 | ZZ_MARK_TARGET(0x80055B94,0x80055BA4,ZZ_55B78_1C); 22 | -------------------------------------------------------------------------------- /srczz/zz_5659c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_5659C: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | A0 <<= 16; 6 | A1 <<= 16; 7 | A0 = (int32_t)A0 >> 16; 8 | RA = 0x800565B8; //ZZ_5659C_1C 9 | A1 = (int32_t)A1 >> 16; 10 | ZZ_CLOCKCYCLES(7,0x800563F0); 11 | goto ZZ_563F0; 12 | ZZ_5659C_1C: 13 | RA = EMU_ReadU32(SP + 16); //+ 0x10 14 | SP += 24; 15 | ZZ_JUMPREGISTER_BEGIN(RA); 16 | ZZ_CLOCKCYCLES_JR(4); 17 | ZZ_JUMPREGISTER(0x80034854,ZZ_347D4_80); 18 | ZZ_JUMPREGISTER_END(); 19 | #endif 20 | ZZ_MARK_TARGET(0x8005659C,0x800565B8,ZZ_5659C); 21 | ZZ_MARK_TARGET(0x800565B8,0x800565C8,ZZ_5659C_1C); 22 | -------------------------------------------------------------------------------- /srczz/zz_4a138.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A138: 3 | V0 = A0 & 0xFFFF; 4 | A0 = V0 << 2; 5 | A1 = 0x80060000; 6 | A1 = EMU_ReadU32(A1 - 12832); //+ 0xFFFFCDE0 7 | AT = 0x80060000; 8 | AT += A0; 9 | A0 = EMU_ReadU32(AT - 12824); //+ 0xFFFFCDE8 10 | V1 = EMU_ReadU32(A1 + 4); //+ 0x4 11 | V0 = (int32_t)V0 < 3; 12 | V1 |= A0; 13 | EMU_Write32(A1 + 4,V1); //+ 0x4 14 | ZZ_JUMPREGISTER_BEGIN(RA); 15 | ZZ_CLOCKCYCLES_JR(13); 16 | ZZ_JUMPREGISTER(0x80015868,ZZ_15738_130); 17 | ZZ_JUMPREGISTER(0x80016A38,ZZ_1658C_4AC); 18 | ZZ_JUMPREGISTER_END(); 19 | #endif 20 | ZZ_MARK_TARGET(0x8004A138,0x8004A16C,ZZ_4A138); 21 | -------------------------------------------------------------------------------- /srczz/zz_15704.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_15704: 3 | V0 = A1 << 1; 4 | V0 += A1; 5 | V0 <<= 2; 6 | V0 = V0 - A1; 7 | V0 <<= 2; 8 | A0 += V0; 9 | V0 = EMU_ReadS16(A0 + 48); //+ 0x30 10 | if (!V0) 11 | { 12 | ZZ_CLOCKCYCLES(10,0x80015730); 13 | goto ZZ_15704_2C; 14 | } 15 | EMU_Write16(A0 + 48,R0); //+ 0x30 16 | ZZ_CLOCKCYCLES(11,0x80015730); 17 | ZZ_15704_2C: 18 | ZZ_JUMPREGISTER_BEGIN(RA); 19 | ZZ_CLOCKCYCLES_JR(2); 20 | ZZ_JUMPREGISTER(0x8001540C,ZZ_15340_CC); 21 | ZZ_JUMPREGISTER_END(); 22 | #endif 23 | ZZ_MARK_TARGET(0x80015704,0x80015730,ZZ_15704); 24 | ZZ_MARK_TARGET(0x80015730,0x80015738,ZZ_15704_2C); 25 | -------------------------------------------------------------------------------- /srczz/zz_172bc.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_172BC: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | A2 = 0x63960000; 6 | A2 |= 0x347F; 7 | RA = 0x800172D4; //ZZ_172BC_18 8 | A1 = 0x1; 9 | ZZ_CLOCKCYCLES(6,0x80017068); 10 | goto ZZ_17068; 11 | ZZ_172BC_18: 12 | RA = EMU_ReadU32(SP + 16); //+ 0x10 13 | SP += 24; 14 | ZZ_JUMPREGISTER_BEGIN(RA); 15 | ZZ_CLOCKCYCLES_JR(4); 16 | ZZ_JUMPREGISTER(0x80012800,ZZ_126BC_144); 17 | ZZ_JUMPREGISTER(0x80012A58,ZZ_126BC_39C); 18 | ZZ_JUMPREGISTER_END(); 19 | #endif 20 | ZZ_MARK_TARGET(0x800172BC,0x800172D4,ZZ_172BC); 21 | ZZ_MARK_TARGET(0x800172D4,0x800172E4,ZZ_172BC_18); 22 | -------------------------------------------------------------------------------- /srczz/zz_1747c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_1747C: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | A2 = 0x63960000; 6 | A2 |= 0x347F; 7 | RA = 0x80017494; //ZZ_1747C_18 8 | A1 = 0x1; 9 | ZZ_CLOCKCYCLES(6,0x8001730C); 10 | goto ZZ_1730C; 11 | ZZ_1747C_18: 12 | RA = EMU_ReadU32(SP + 16); //+ 0x10 13 | SP += 24; 14 | ZZ_JUMPREGISTER_BEGIN(RA); 15 | ZZ_CLOCKCYCLES_JR(4); 16 | ZZ_JUMPREGISTER(0x80012800,ZZ_126BC_144); 17 | ZZ_JUMPREGISTER(0x80012A58,ZZ_126BC_39C); 18 | ZZ_JUMPREGISTER_END(); 19 | #endif 20 | ZZ_MARK_TARGET(0x8001747C,0x80017494,ZZ_1747C); 21 | ZZ_MARK_TARGET(0x80017494,0x800174A4,ZZ_1747C_18); 22 | -------------------------------------------------------------------------------- /srczz/zz_4e344.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4E344: 3 | V0 = 0x10000000; 4 | V1 = 0x80060000; 5 | V1 = EMU_ReadU32(V1 - 8056); //+ 0xFFFFE088 6 | A0 |= V0; 7 | EMU_Write32(V1,A0); 8 | V0 = 0x80060000; 9 | V0 = EMU_ReadU32(V0 - 8060); //+ 0xFFFFE084 10 | V1 = 0xFF0000; 11 | V0 = EMU_ReadU32(V0); 12 | V1 |= 0xFFFF; 13 | ZZ_JUMPREGISTER_BEGIN(RA); 14 | V0 &= V1; 15 | ZZ_CLOCKCYCLES_JR(12); 16 | ZZ_JUMPREGISTER(0x8004DCC8,ZZ_4DB50_178); 17 | ZZ_JUMPREGISTER(0x8004DCDC,ZZ_4DB50_18C); 18 | ZZ_JUMPREGISTER(0x8004DCF4,ZZ_4DB50_1A4); 19 | ZZ_JUMPREGISTER_END(); 20 | #endif 21 | ZZ_MARK_TARGET(0x8004E344,0x8004E374,ZZ_4E344); 22 | -------------------------------------------------------------------------------- /src/main.c: -------------------------------------------------------------------------------- 1 | #include "common.h" 2 | #include 3 | #include "emu.h" 4 | #include "core.h" 5 | 6 | int main(int argc,char **argv) 7 | { 8 | if (SDL_Init(0) < 0) 9 | { 10 | // no logging available because init failed 11 | fprintf(stderr,"SDL_Init failed: %s\n",SDL_GetError()); 12 | SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR,APP_TITLE,SDL_GetError(),NULL); 13 | return EXIT_FAILURE; 14 | } 15 | #ifdef NDEBUG 16 | SDL_LogSetAllPriority(SDL_LOG_PRIORITY_INFO); 17 | #else 18 | SDL_LogSetAllPriority(SDL_LOG_PRIORITY_DEBUG); 19 | #endif 20 | EMU_Init(); 21 | CORE_Start(); 22 | SDL_Quit(); 23 | return EXIT_SUCCESS; 24 | } 25 | -------------------------------------------------------------------------------- /srczz/zz_5ab64.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_5AB64: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | A3 = A2; 6 | A1 <<= 16; 7 | A1 = (int32_t)A1 >> 16; 8 | RA = 0x8005AB80; //ZZ_5AB64_1C 9 | A2 = 1; 10 | ZZ_CLOCKCYCLES(7,0x8005AB94); 11 | goto ZZ_5AB94; 12 | ZZ_5AB64_1C: 13 | V0 <<= 16; 14 | RA = EMU_ReadU32(SP + 16); //+ 0x10 15 | V0 = (int32_t)V0 >> 16; 16 | ZZ_JUMPREGISTER_BEGIN(RA); 17 | SP += 24; 18 | ZZ_CLOCKCYCLES_JR(5); 19 | ZZ_JUMPREGISTER(0x80034404,ZZ_34204_200); 20 | ZZ_JUMPREGISTER_END(); 21 | #endif 22 | ZZ_MARK_TARGET(0x8005AB64,0x8005AB80,ZZ_5AB64); 23 | ZZ_MARK_TARGET(0x8005AB80,0x8005AB94,ZZ_5AB64_1C); 24 | -------------------------------------------------------------------------------- /srczz/zz_164f4.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_164F4: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | V0 = EMU_ReadU32(A0 + 4); //+ 0x4 6 | RA = 0x80016508; //ZZ_164F4_14 7 | EMU_Write32(A0 + 8,V0); //+ 0x8 8 | ZZ_CLOCKCYCLES(5,0x800164E4); 9 | goto ZZ_164E4; 10 | ZZ_164F4_14: 11 | RA = EMU_ReadU32(SP + 16); //+ 0x10 12 | SP += 24; 13 | ZZ_JUMPREGISTER_BEGIN(RA); 14 | ZZ_CLOCKCYCLES_JR(4); 15 | ZZ_JUMPREGISTER(0x800163F0,ZZ_16328_C8); 16 | ZZ_JUMPREGISTER(0x80016B60,ZZ_1658C_5D4); 17 | ZZ_JUMPREGISTER_END(); 18 | #endif 19 | ZZ_MARK_TARGET(0x800164F4,0x80016508,ZZ_164F4); 20 | ZZ_MARK_TARGET(0x80016508,0x80016518,ZZ_164F4_14); 21 | -------------------------------------------------------------------------------- /srczz/zz_4f2b0.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4F2B0: 3 | GTE_SetRegister(GTE_DREG_VXY0,EMU_ReadU32(A0)); 4 | GTE_SetRegister(GTE_DREG_VZ0,EMU_ReadU32(A0 + 4)); //+ 0x4 5 | GTE_RotateTranslateProjectSingle(); 6 | EMU_Write32(A1,GTE_GetRegister(GTE_DREG_SXY2)); 7 | EMU_Write32(A2,GTE_GetRegister(GTE_DREG_IR0)); 8 | V1 = GTE_GetRegister(GTE_CREG_FLAG); 9 | V0 = GTE_GetRegister(GTE_DREG_SZ3); 10 | EMU_Write32(A3,V1); 11 | ZZ_JUMPREGISTER_BEGIN(RA); 12 | V0 = (int32_t)V0 >> 2; 13 | ZZ_CLOCKCYCLES_JR(11); 14 | ZZ_JUMPREGISTER(0x8001F050,ZZ_1EFA8_A8); 15 | ZZ_JUMPREGISTER_END(); 16 | #endif 17 | ZZ_MARK_TARGET(0x8004F2B0,0x8004F2DC,ZZ_4F2B0); 18 | -------------------------------------------------------------------------------- /srczz/zz_36494.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_36494: 3 | V0 = EMU_ReadU32(GP + 232); //+ 0xE8 4 | V0 = EMU_ReadU32(V0 + 4); //+ 0x4 5 | ZZ_JUMPREGISTER_BEGIN(RA); 6 | ZZ_CLOCKCYCLES_JR(5); 7 | ZZ_JUMPREGISTER(0x80036724,ZZ_36714_10); 8 | ZZ_JUMPREGISTER(0x800367F0,ZZ_367E0_10); 9 | ZZ_JUMPREGISTER(0x80036944,ZZ_3692C_18); 10 | ZZ_JUMPREGISTER(0x800348FC,ZZ_348EC_10); 11 | ZZ_JUMPREGISTER(0x80034914,ZZ_348EC_28); 12 | ZZ_JUMPREGISTER(0x800349E4,ZZ_348EC_F8); 13 | ZZ_JUMPREGISTER(0x8003632C,ZZ_3631C_10); 14 | ZZ_JUMPREGISTER(0x80034AB0,ZZ_34A0C_A4); 15 | ZZ_JUMPREGISTER_END(); 16 | #endif 17 | ZZ_MARK_TARGET(0x80036494,0x800364A8,ZZ_36494); 18 | -------------------------------------------------------------------------------- /srczz/zz_4f1f0.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4F1F0: 3 | T0 = EMU_ReadU32(A0); 4 | T1 = EMU_ReadU32(A0 + 4); //+ 0x4 5 | T2 = EMU_ReadU32(A0 + 8); //+ 0x8 6 | T3 = EMU_ReadU32(A0 + 12); //+ 0xC 7 | T4 = EMU_ReadU32(A0 + 16); //+ 0x10 8 | GTE_SetRegister(GTE_CREG_LR1_LR2,T0); 9 | GTE_SetRegister(GTE_CREG_LR3_LG1,T1); 10 | GTE_SetRegister(GTE_CREG_LG2_LG3,T2); 11 | GTE_SetRegister(GTE_CREG_LB1_LB2,T3); 12 | GTE_SetRegister(GTE_CREG_LB3_NONE,T4); 13 | ZZ_JUMPREGISTER_BEGIN(RA); 14 | ZZ_CLOCKCYCLES_JR(12); 15 | ZZ_JUMPREGISTER(0x80017B8C,ZZ_17AB0_DC); 16 | ZZ_JUMPREGISTER_END(); 17 | #endif 18 | ZZ_MARK_TARGET(0x8004F1F0,0x8004F220,ZZ_4F1F0); 19 | -------------------------------------------------------------------------------- /srczz/zz_4a16c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A16C: 3 | A0 &= 0xFFFF; 4 | A0 <<= 2; 5 | A1 = 0x80060000; 6 | A1 = EMU_ReadU32(A1 - 12832); //+ 0xFFFFCDE0 7 | AT = 0x80060000; 8 | AT += A0; 9 | V0 = EMU_ReadU32(AT - 12824); //+ 0xFFFFCDE8 10 | V1 = EMU_ReadU32(A1 + 4); //+ 0x4 11 | V0 = ~V0; 12 | V1 &= V0; 13 | V0 = 1; 14 | EMU_Write32(A1 + 4,V1); //+ 0x4 15 | ZZ_JUMPREGISTER_BEGIN(RA); 16 | ZZ_CLOCKCYCLES_JR(14); 17 | ZZ_JUMPREGISTER(0x8001591C,ZZ_158C4_58); 18 | ZZ_JUMPREGISTER(0x8001581C,ZZ_15738_E4); 19 | ZZ_JUMPREGISTER(0x800169DC,ZZ_1658C_450); 20 | ZZ_JUMPREGISTER_END(); 21 | #endif 22 | ZZ_MARK_TARGET(0x8004A16C,0x8004A1A4,ZZ_4A16C); 23 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/BREAKInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class BREAKInstruction : Instruction 6 | { 7 | private int func; 8 | 9 | public BREAKInstruction(int func) 10 | { 11 | this.func = func; 12 | } 13 | 14 | public override string ToString() 15 | { 16 | return string.Format("BREAK {0}",func); 17 | } 18 | 19 | public override void Discompile(Program p,int address,bool direct) 20 | { 21 | p.WriteLine("EMU_Break({0});",func); 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /srczz/zz_46d78.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_46D78: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | RA = 0x80046D88; //ZZ_46D78_10 6 | ZZ_CLOCKCYCLES(4,0x80047940); 7 | goto ZZ_47940; 8 | ZZ_46D78_10: 9 | RA = EMU_ReadU32(SP + 16); //+ 0x10 10 | SP += 24; 11 | ZZ_JUMPREGISTER_BEGIN(RA); 12 | ZZ_CLOCKCYCLES_JR(4); 13 | ZZ_JUMPREGISTER(0x800133FC,ZZ_13304_F8); 14 | ZZ_JUMPREGISTER(0x800130A4,ZZ_12FE8_BC); 15 | ZZ_JUMPREGISTER(0x800130BC,ZZ_12FE8_D4); 16 | ZZ_JUMPREGISTER(0x80012F44,ZZ_12F10_34); 17 | ZZ_JUMPREGISTER_END(); 18 | #endif 19 | ZZ_MARK_TARGET(0x80046D78,0x80046D88,ZZ_46D78); 20 | ZZ_MARK_TARGET(0x80046D88,0x80046D98,ZZ_46D78_10); 21 | -------------------------------------------------------------------------------- /srczz/zz_4f2e0.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4F2E0: 3 | GTE_SetRegister(GTE_DREG_VXY0,EMU_ReadU32(A0)); 4 | GTE_SetRegister(GTE_DREG_VZ0,EMU_ReadU32(A0 + 4)); //+ 0x4 5 | GTE_MultiplyAdd_V0_Rotation_Translation(); 6 | EMU_Write32(A1,GTE_GetRegister(GTE_DREG_MAC1)); 7 | EMU_Write32(A1 + 4,GTE_GetRegister(GTE_DREG_MAC2)); //+ 0x4 8 | EMU_Write32(A1 + 8,GTE_GetRegister(GTE_DREG_MAC3)); //+ 0x8 9 | V0 = GTE_GetRegister(GTE_CREG_FLAG); 10 | ZZ_JUMPREGISTER_BEGIN(RA); 11 | EMU_Write32(A2,V0); 12 | ZZ_CLOCKCYCLES_JR(10); 13 | ZZ_JUMPREGISTER(0x8001EF64,ZZ_1EE74_F0); 14 | ZZ_JUMPREGISTER_END(); 15 | #endif 16 | ZZ_MARK_TARGET(0x8004F2E0,0x8004F308,ZZ_4F2E0); 17 | -------------------------------------------------------------------------------- /srczz/zz_52b5c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_52B5C: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | A0 <<= 16; 6 | A1 <<= 16; 7 | A2 <<= 16; 8 | A0 = (int32_t)A0 >> 16; 9 | A1 = (int32_t)A1 >> 16; 10 | RA = 0x80052B80; //ZZ_52B5C_24 11 | A2 = (int32_t)A2 >> 16; 12 | ZZ_CLOCKCYCLES(9,0x800529F4); 13 | goto ZZ_529F4; 14 | ZZ_52B5C_24: 15 | RA = EMU_ReadU32(SP + 16); //+ 0x10 16 | SP += 24; 17 | ZZ_JUMPREGISTER_BEGIN(RA); 18 | ZZ_CLOCKCYCLES_JR(4); 19 | ZZ_JUMPREGISTER(0x80034500,ZZ_34204_2FC); 20 | ZZ_JUMPREGISTER_END(); 21 | #endif 22 | ZZ_MARK_TARGET(0x80052B5C,0x80052B80,ZZ_52B5C); 23 | ZZ_MARK_TARGET(0x80052B80,0x80052B90,ZZ_52B5C_24); 24 | -------------------------------------------------------------------------------- /srczz/zz_52de4.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_52DE4: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | A0 <<= 16; 6 | A1 <<= 16; 7 | A2 <<= 16; 8 | A0 = (int32_t)A0 >> 16; 9 | A1 = (int32_t)A1 >> 16; 10 | RA = 0x80052E08; //ZZ_52DE4_24 11 | A2 = (int32_t)A2 >> 16; 12 | ZZ_CLOCKCYCLES(9,0x80052C88); 13 | goto ZZ_52C88; 14 | ZZ_52DE4_24: 15 | RA = EMU_ReadU32(SP + 16); //+ 0x10 16 | SP += 24; 17 | ZZ_JUMPREGISTER_BEGIN(RA); 18 | ZZ_CLOCKCYCLES_JR(4); 19 | ZZ_JUMPREGISTER(0x80034664,ZZ_34578_EC); 20 | ZZ_JUMPREGISTER_END(); 21 | #endif 22 | ZZ_MARK_TARGET(0x80052DE4,0x80052E08,ZZ_52DE4); 23 | ZZ_MARK_TARGET(0x80052E08,0x80052E18,ZZ_52DE4_24); 24 | -------------------------------------------------------------------------------- /srczz/zz_19f60.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_19F60: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | A2 = A0; 6 | A0 = 0x80020000; 7 | A0 -= 29108; 8 | A1 = 0x80020000; 9 | A1 -= 24984; 10 | RA = 0x80019F84; //ZZ_19F60_24 11 | ZZ_CLOCKCYCLES(9,0x80018F0C); 12 | goto ZZ_18F0C; 13 | ZZ_19F60_24: 14 | RA = EMU_ReadU32(SP + 16); //+ 0x10 15 | SP += 24; 16 | ZZ_JUMPREGISTER_BEGIN(RA); 17 | ZZ_CLOCKCYCLES_JR(4); 18 | ZZ_JUMPREGISTER(0x800202E0,ZZ_20290_50); 19 | ZZ_JUMPREGISTER(0x8001A00C,ZZ_19F94_78); 20 | ZZ_JUMPREGISTER_END(); 21 | #endif 22 | ZZ_MARK_TARGET(0x80019F60,0x80019F84,ZZ_19F60); 23 | ZZ_MARK_TARGET(0x80019F84,0x80019F94,ZZ_19F60_24); 24 | -------------------------------------------------------------------------------- /srczz/zz_35dd8.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_35DD8: 3 | V1 = EMU_ReadU32(GP + 232); //+ 0xE8 4 | V0 = EMU_ReadU32(V1 + 20); //+ 0x14 5 | A1 = EMU_ReadU32(V1 + 16); //+ 0x10 6 | A0 = V0 + 1; 7 | V0 = (int32_t)V0 < (int32_t)A1; 8 | V0 ^= 0x1; 9 | ZZ_JUMPREGISTER_BEGIN(RA); 10 | EMU_Write32(V1 + 20,A0); //+ 0x14 11 | ZZ_CLOCKCYCLES_JR(9); 12 | ZZ_JUMPREGISTER(0x80034B90,ZZ_34B44_4C); 13 | ZZ_JUMPREGISTER(0x80034D10,ZZ_34BCC_144); 14 | ZZ_JUMPREGISTER(0x80035D80,ZZ_35D34_4C); 15 | ZZ_JUMPREGISTER(0x80034CF8,ZZ_34BCC_12C); 16 | ZZ_JUMPREGISTER(0x80034D88,ZZ_34D74_14); 17 | ZZ_JUMPREGISTER_END(); 18 | #endif 19 | ZZ_MARK_TARGET(0x80035DD8,0x80035DFC,ZZ_35DD8); 20 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | CFLAGS := -g -Wall -std=c99 2 | CXXFLAGS := -g -Wall -std=c++11 3 | LDFLAGS := -g 4 | CSOURCES := $(shell find src -name "*.c") 5 | CXXSOURCES := $(shell find src -name "*.cc") 6 | OBJECTS := $(CSOURCES:.c=.o) $(CXXSOURCES:.cc=.o) 7 | DEPENDS := $(CSOURCES:.c=.d) $(CXXSOURCES:.cc=.d) 8 | 9 | all: c2c 10 | 11 | clean: 12 | rm -f $(OBJECTS) 13 | rm -f $(DEPENDS) 14 | 15 | %.o: %.c 16 | $(CC) -MMD -o $@ -c $< $(CFLAGS) `sdl2-config --cflags` 17 | 18 | %.o: %.cc 19 | $(CXX) -MMD -o $@ -c $< $(CXXFLAGS) `sdl2-config --cflags` 20 | 21 | c2c: $(OBJECTS) 22 | $(CXX) -o $@ $^ $(LDFLAGS) `sdl2-config --libs` 23 | 24 | -include $(DEPENDS) 25 | 26 | .PHONY: all clean 27 | -------------------------------------------------------------------------------- /srcdisasm/PSXException.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Runtime.Serialization; 3 | 4 | namespace PSXDiscompile 5 | { 6 | [Serializable] 7 | public class PSXException : Exception 8 | { 9 | public PSXException() 10 | { 11 | } 12 | 13 | public PSXException(string message) : base(message) 14 | { 15 | } 16 | 17 | public PSXException(string message,Exception innerException) : base(message,innerException) 18 | { 19 | } 20 | 21 | protected PSXException(SerializationInfo info,StreamingContext context) : base(info,context) 22 | { 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /srczz/zz_54bd0.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_54BD0: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | A0 <<= 16; 6 | A1 <<= 16; 7 | A3 <<= 16; 8 | A0 = (int32_t)A0 >> 16; 9 | A1 = (int32_t)A1 >> 16; 10 | A2 &= 0xFF; 11 | RA = 0x80054BF8; //ZZ_54BD0_28 12 | A3 = (int32_t)A3 >> 16; 13 | ZZ_CLOCKCYCLES(10,0x80054CF8); 14 | goto ZZ_54CF8; 15 | ZZ_54BD0_28: 16 | RA = EMU_ReadU32(SP + 16); //+ 0x10 17 | SP += 24; 18 | ZZ_JUMPREGISTER_BEGIN(RA); 19 | ZZ_CLOCKCYCLES_JR(4); 20 | ZZ_JUMPREGISTER(0x80034838,ZZ_347D4_64); 21 | ZZ_JUMPREGISTER_END(); 22 | #endif 23 | ZZ_MARK_TARGET(0x80054BD0,0x80054BF8,ZZ_54BD0); 24 | ZZ_MARK_TARGET(0x80054BF8,0x80054C08,ZZ_54BD0_28); 25 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/InvalidInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class InvalidInstruction : Instruction 6 | { 7 | private int value; 8 | 9 | public InvalidInstruction(int value) 10 | { 11 | this.value = value; 12 | } 13 | 14 | public override string ToString() 15 | { 16 | return string.Format("INVALID 0x{0:X8}",value); 17 | } 18 | 19 | public override void Discompile(Program p,int address,bool direct) 20 | { 21 | throw new PSXException("Unrecognized opcode."); 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /srczz/zz_5b358.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_5B358: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | RA = 0x8005B368; //ZZ_5B358_10 6 | ZZ_CLOCKCYCLES(4,0x8005B3A0); 7 | goto ZZ_5B3A0; 8 | ZZ_5B358_10: 9 | RA = 0x8005B370; //ZZ_5B358_18 10 | ZZ_CLOCKCYCLES(2,0x8005B3B0); 11 | goto ZZ_5B3B0; 12 | ZZ_5B358_18: 13 | RA = EMU_ReadU32(SP + 16); //+ 0x10 14 | SP += 24; 15 | ZZ_JUMPREGISTER_BEGIN(RA); 16 | ZZ_CLOCKCYCLES_JR(4); 17 | ZZ_JUMPREGISTER(0x80036658,ZZ_36648_10); 18 | ZZ_JUMPREGISTER_END(); 19 | #endif 20 | ZZ_MARK_TARGET(0x8005B358,0x8005B368,ZZ_5B358); 21 | ZZ_MARK_TARGET(0x8005B368,0x8005B370,ZZ_5B358_10); 22 | ZZ_MARK_TARGET(0x8005B370,0x8005B380,ZZ_5B358_18); 23 | -------------------------------------------------------------------------------- /srczz/zz_43a34.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_43A34: 3 | A0 = EMU_ReadU32(SP + 76); //+ 0x4C 4 | A2 = 1904; 5 | T9 += A2; 6 | A0 += A2; 7 | EMU_Write32(V1 + 240,T9); //+ 0xF0 8 | EMU_Write32(V1 + 244,T9); //+ 0xF4 9 | ZZ_JUMPREGISTER_BEGIN(RA); 10 | EMU_Write32(V1 + 248,A0); //+ 0xF8 11 | ZZ_CLOCKCYCLES_JR(8); 12 | ZZ_JUMPREGISTER(0x8004040C,ZZ_3FFAC_460); 13 | ZZ_JUMPREGISTER(0x80041A54,ZZ_41A1C_38); 14 | ZZ_JUMPREGISTER(0x8003E184,ZZ_3DFAC_1D8); 15 | ZZ_JUMPREGISTER(0x800401C4,ZZ_3FFAC_218); 16 | ZZ_JUMPREGISTER(0x80041274,ZZ_40FAC_2C8); 17 | ZZ_JUMPREGISTER(0x8003F234,ZZ_3EFAC_288); 18 | ZZ_JUMPREGISTER_END(); 19 | #endif 20 | ZZ_MARK_TARGET(0x80043A34,0x80043A54,ZZ_43A34); 21 | -------------------------------------------------------------------------------- /srczz/zz_576fc.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_576FC: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | A2 = 202; 6 | RA = 0x80057710; //ZZ_576FC_14 7 | A3 = 203; 8 | ZZ_CLOCKCYCLES(5,0x80050EA0); 9 | goto ZZ_50EA0; 10 | ZZ_576FC_14: 11 | RA = EMU_ReadU32(SP + 16); //+ 0x10 12 | SP += 24; 13 | ZZ_JUMPREGISTER_BEGIN(RA); 14 | ZZ_CLOCKCYCLES_JR(4); 15 | ZZ_JUMPREGISTER(0x80057424,ZZ_572C0_164); 16 | ZZ_JUMPREGISTER(0x80058E74,ZZ_58E2C_48); 17 | ZZ_JUMPREGISTER(0x800584F8,ZZ_582A4_254); 18 | ZZ_JUMPREGISTER(0x80058DBC,ZZ_58900_4BC); 19 | ZZ_JUMPREGISTER_END(); 20 | #endif 21 | ZZ_MARK_TARGET(0x800576FC,0x80057710,ZZ_576FC); 22 | ZZ_MARK_TARGET(0x80057710,0x80057720,ZZ_576FC_14); 23 | -------------------------------------------------------------------------------- /srczz/zz_4f1c0.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4F1C0: 3 | T0 = EMU_ReadU32(A0); 4 | T1 = EMU_ReadU32(A0 + 4); //+ 0x4 5 | T2 = EMU_ReadU32(A0 + 8); //+ 0x8 6 | T3 = EMU_ReadU32(A0 + 12); //+ 0xC 7 | T4 = EMU_ReadU32(A0 + 16); //+ 0x10 8 | GTE_SetRegister(GTE_CREG_RT11_RT12,T0); 9 | GTE_SetRegister(GTE_CREG_RT13_RT21,T1); 10 | GTE_SetRegister(GTE_CREG_RT22_RT23,T2); 11 | GTE_SetRegister(GTE_CREG_RT31_RT32,T3); 12 | GTE_SetRegister(GTE_CREG_RT33_NONE,T4); 13 | ZZ_JUMPREGISTER_BEGIN(RA); 14 | ZZ_CLOCKCYCLES_JR(12); 15 | ZZ_JUMPREGISTER(0x8001EFE4,ZZ_1EFA8_3C); 16 | ZZ_JUMPREGISTER(0x8001EEC8,ZZ_1EE74_54); 17 | ZZ_JUMPREGISTER_END(); 18 | #endif 19 | ZZ_MARK_TARGET(0x8004F1C0,0x8004F1F0,ZZ_4F1C0); 20 | -------------------------------------------------------------------------------- /srczz/zz_315a4.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_315A4: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | A2 = EMU_ReadU32(A1); 6 | V0 = EMU_ReadU32(A0); 7 | V1 = EMU_ReadU32(A1 + 4); //+ 0x4 8 | A1 = EMU_ReadU32(A0 + 4); //+ 0x4 9 | A0 = A2 - V0; 10 | RA = 0x800315C8; //ZZ_315A4_24 11 | A1 = V1 - A1; 12 | ZZ_CLOCKCYCLES(9,0x8004F310); 13 | goto ZZ_4F310; 14 | ZZ_315A4_24: 15 | RA = EMU_ReadU32(SP + 16); //+ 0x10 16 | V0 &= 0xFFF; 17 | ZZ_JUMPREGISTER_BEGIN(RA); 18 | SP += 24; 19 | ZZ_CLOCKCYCLES_JR(4); 20 | ZZ_JUMPREGISTER(0x80037B10,ZZ_37930_1E0); 21 | ZZ_JUMPREGISTER_END(); 22 | #endif 23 | ZZ_MARK_TARGET(0x800315A4,0x800315C8,ZZ_315A4); 24 | ZZ_MARK_TARGET(0x800315C8,0x800315D8,ZZ_315A4_24); 25 | -------------------------------------------------------------------------------- /srczz/zz_4e2f8.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4E2F8: 3 | V1 = 0x4000000; 4 | V0 = 0x80060000; 5 | V0 = EMU_ReadU32(V0 - 8056); //+ 0xFFFFE088 6 | V1 |= 0x2; 7 | EMU_Write32(V0,V1); 8 | V0 = 0x80060000; 9 | V0 = EMU_ReadU32(V0 - 8052); //+ 0xFFFFE08C 10 | EMU_Write32(V0,A0); 11 | V0 = 0x80060000; 12 | V0 = EMU_ReadU32(V0 - 8048); //+ 0xFFFFE090 13 | V1 = 0x1000000; 14 | EMU_Write32(V0,R0); 15 | V0 = 0x80060000; 16 | V0 = EMU_ReadU32(V0 - 8044); //+ 0xFFFFE094 17 | V1 |= 0x401; 18 | EMU_Write32(V0,V1); 19 | ZZ_JUMPREGISTER_BEGIN(RA); 20 | ZZ_CLOCKCYCLES_JR(19); 21 | ZZ_JUMPREGISTER(0x8004DD90,ZZ_4DB50_240); 22 | ZZ_JUMPREGISTER_END(); 23 | #endif 24 | ZZ_MARK_TARGET(0x8004E2F8,0x8004E344,ZZ_4E2F8); 25 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Multiply/MFHIInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class MFHIInstruction : Instruction 6 | { 7 | private Register rd; 8 | 9 | public MFHIInstruction(Register rd) 10 | { 11 | this.rd = rd; 12 | } 13 | 14 | public override string ToString() 15 | { 16 | return string.Format("MFHI ${0}",rd); 17 | } 18 | 19 | public override void Discompile(Program p,int address,bool direct) 20 | { 21 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 22 | p.WriteLine("{0} = HI;",rd); 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Multiply/MFLOInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class MFLOInstruction : Instruction 6 | { 7 | private Register rd; 8 | 9 | public MFLOInstruction(Register rd) 10 | { 11 | this.rd = rd; 12 | } 13 | 14 | public override string ToString() 15 | { 16 | return string.Format("MFLO ${0}",rd); 17 | } 18 | 19 | public override void Discompile(Program p,int address,bool direct) 20 | { 21 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 22 | p.WriteLine("{0} = LO;",rd); 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Multiply/MTHIInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class MTHIInstruction : Instruction 6 | { 7 | private Register rs; 8 | 9 | public MTHIInstruction(Register rs) 10 | { 11 | this.rs = rs; 12 | } 13 | 14 | public override string ToString() 15 | { 16 | return string.Format("MTHI ${0}",rs); 17 | } 18 | 19 | public override void Discompile(Program p,int address,bool direct) 20 | { 21 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 22 | p.WriteLine("HI = {0};",rs); 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Multiply/MTLOInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class MTLOInstruction : Instruction 6 | { 7 | private Register rs; 8 | 9 | public MTLOInstruction(Register rs) 10 | { 11 | this.rs = rs; 12 | } 13 | 14 | public override string ToString() 15 | { 16 | return string.Format("MTLO ${0}",rs); 17 | } 18 | 19 | public override void Discompile(Program p,int address,bool direct) 20 | { 21 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 22 | p.WriteLine("LO = {0};",rs); 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /srczz/zz_4b908.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4B908: 3 | if (!A1) 4 | { 5 | ZZ_CLOCKCYCLES(2,0x8004B91C); 6 | goto ZZ_4B908_14; 7 | } 8 | V0 = EMU_ReadU8(A0 + 7); //+ 0x7 9 | V0 |= 0x2; 10 | ZZ_CLOCKCYCLES(5,0x8004B928); 11 | goto ZZ_4B908_20; 12 | ZZ_4B908_14: 13 | V0 = EMU_ReadU8(A0 + 7); //+ 0x7 14 | V0 &= 0xFD; 15 | ZZ_CLOCKCYCLES(3,0x8004B928); 16 | ZZ_4B908_20: 17 | ZZ_JUMPREGISTER_BEGIN(RA); 18 | EMU_Write8(A0 + 7,V0); //+ 0x7 19 | ZZ_CLOCKCYCLES_JR(2); 20 | ZZ_JUMPREGISTER(0x80016CFC,ZZ_16C38_C4); 21 | ZZ_JUMPREGISTER_END(); 22 | #endif 23 | ZZ_MARK_TARGET(0x8004B908,0x8004B91C,ZZ_4B908); 24 | ZZ_MARK_TARGET(0x8004B91C,0x8004B928,ZZ_4B908_14); 25 | ZZ_MARK_TARGET(0x8004B928,0x8004B930,ZZ_4B908_20); 26 | -------------------------------------------------------------------------------- /srczz/zz_1f260.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_1F260: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU32(V0 + 30772); //+ 0x7834 5 | V1 = EMU_ReadU32(V0 + 8); //+ 0x8 6 | V1 <<= 8; 7 | AT = 0x80070000; 8 | EMU_Write32(AT - 12792,V1); //+ 0xFFFFCE08 9 | V1 = EMU_ReadU32(V0 + 4); //+ 0x4 10 | if (!V1) 11 | { 12 | V0 = -14; 13 | ZZ_CLOCKCYCLES(12,0x8001F294); 14 | goto ZZ_1F260_34; 15 | } 16 | V0 = -14; 17 | V0 = -255; 18 | ZZ_CLOCKCYCLES(13,0x8001F294); 19 | ZZ_1F260_34: 20 | ZZ_JUMPREGISTER_BEGIN(RA); 21 | ZZ_CLOCKCYCLES_JR(2); 22 | ZZ_JUMPREGISTER(0x80015304,ZZ_14D6C_598); 23 | ZZ_JUMPREGISTER_END(); 24 | #endif 25 | ZZ_MARK_TARGET(0x8001F260,0x8001F294,ZZ_1F260); 26 | ZZ_MARK_TARGET(0x8001F294,0x8001F29C,ZZ_1F260_34); 27 | -------------------------------------------------------------------------------- /srczz/zz_4aa04.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4AA04: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU32(V0 - 8452); //+ 0xFFFFDEFC 5 | SP -= 24; 6 | EMU_Write32(SP + 16,RA); //+ 0x10 7 | V0 = EMU_ReadU32(V0 + 16); //+ 0x10 8 | ZZ_JUMPREGISTER_BEGIN(V0); 9 | RA = 0x8004AA24; //ZZ_4AA04_20 10 | ZZ_CLOCKCYCLES_JR(8); 11 | // UNIMPLEMENTED JUMP-TO-REGISTER-AND-LINK (V0,8004AA1C) 12 | ZZ_JUMPREGISTER_END(); 13 | ZZ_4AA04_20: 14 | RA = EMU_ReadU32(SP + 16); //+ 0x10 15 | SP += 24; 16 | ZZ_JUMPREGISTER_BEGIN(RA); 17 | ZZ_CLOCKCYCLES_JR(4); 18 | ZZ_JUMPREGISTER(0x800158F0,ZZ_158C4_2C); 19 | ZZ_JUMPREGISTER_END(); 20 | #endif 21 | ZZ_MARK_TARGET(0x8004AA04,0x8004AA24,ZZ_4AA04); 22 | ZZ_MARK_TARGET(0x8004AA24,0x8004AA34,ZZ_4AA04_20); 23 | -------------------------------------------------------------------------------- /srczz/zz_56390.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_56390: 3 | A0 <<= 16; 4 | V0 = 0x80070000; 5 | V0 -= 15268; 6 | A0 = (int32_t)A0 >> 14; 7 | A0 += V0; 8 | A1 <<= 16; 9 | A1 = (int32_t)A1 >> 16; 10 | V0 = A1 << 1; 11 | V0 += A1; 12 | V0 <<= 2; 13 | V0 = V0 - A1; 14 | V0 <<= 4; 15 | V1 = EMU_ReadU32(A0); 16 | A1 = 1; 17 | V1 += V0; 18 | EMU_Write8(V1 + 20,A1); //+ 0x14 19 | V1 = EMU_ReadU32(A0); 20 | V0 += V1; 21 | V1 = EMU_ReadU32(V0 + 152); //+ 0x98 22 | A0 = -9; 23 | V1 &= A0; 24 | ZZ_JUMPREGISTER_BEGIN(RA); 25 | EMU_Write32(V0 + 152,V1); //+ 0x98 26 | ZZ_CLOCKCYCLES_JR(24); 27 | ZZ_JUMPREGISTER(0x80055364,ZZ_5519C_1C8); 28 | ZZ_JUMPREGISTER_END(); 29 | #endif 30 | ZZ_MARK_TARGET(0x80056390,0x800563F0,ZZ_56390); 31 | -------------------------------------------------------------------------------- /srczz/zz_13f80.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_13F80: 3 | SP -= 32; 4 | EMU_Write32(SP + 24,RA); //+ 0x18 5 | V0 = EMU_ReadS8(A0 + 14); //+ 0xE 6 | if (!V0) 7 | { 8 | V1 = V0; 9 | ZZ_CLOCKCYCLES(6,0x80013FA4); 10 | goto ZZ_13F80_24; 11 | } 12 | V1 = V0; 13 | V0 = V1 - 1; 14 | RA = 0x80013FA4; //ZZ_13F80_24 15 | EMU_Write8(A0 + 14,V0); //+ 0xE 16 | ZZ_CLOCKCYCLES(9,0x80013F14); 17 | goto ZZ_13F14; 18 | ZZ_13F80_24: 19 | RA = EMU_ReadU32(SP + 24); //+ 0x18 20 | SP += 32; 21 | ZZ_JUMPREGISTER_BEGIN(RA); 22 | ZZ_CLOCKCYCLES_JR(4); 23 | ZZ_JUMPREGISTER(0x800141FC,ZZ_1417C_80); 24 | ZZ_JUMPREGISTER_END(); 25 | #endif 26 | ZZ_MARK_TARGET(0x80013F80,0x80013FA4,ZZ_13F80); 27 | ZZ_MARK_TARGET(0x80013FA4,0x80013FB4,ZZ_13F80_24); 28 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/SYSCALLInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class SYSCALLInstruction : Instruction 6 | { 7 | private int func; 8 | 9 | public SYSCALLInstruction(int func) 10 | { 11 | this.func = func; 12 | } 13 | 14 | public override string ToString() 15 | { 16 | return string.Format("SYSCALL {0}",func); 17 | } 18 | 19 | public override void Discompile(Program p,int address,bool direct) 20 | { 21 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 22 | p.WriteLine("EMU_Syscall(0x{0:X});",address); 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /srczz/zz_4aa8c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4AA8C: 3 | V1 = 0x80060000; 4 | V1 = EMU_ReadU32(V1 - 8444); //+ 0xFFFFDF04 5 | V0 = EMU_ReadU16(V1); 6 | EMU_Write16(V1,A0); 7 | ZZ_JUMPREGISTER_BEGIN(RA); 8 | ZZ_CLOCKCYCLES_JR(7); 9 | ZZ_JUMPREGISTER(0x8004E97C,ZZ_4E964_18); 10 | ZZ_JUMPREGISTER(0x8004EA98,ZZ_4E964_134); 11 | ZZ_JUMPREGISTER(0x8004E6A8,ZZ_4E678_30); 12 | ZZ_JUMPREGISTER(0x8004E40C,ZZ_4E398_74); 13 | ZZ_JUMPREGISTER(0x8004E8C0,ZZ_4E678_248); 14 | ZZ_JUMPREGISTER(0x8004E4D8,ZZ_4E398_140); 15 | ZZ_JUMPREGISTER(0x8004ED10,ZZ_4EC3C_D4); 16 | ZZ_JUMPREGISTER(0x8004E634,ZZ_4E398_29C); 17 | ZZ_JUMPREGISTER(0x8004ED8C,ZZ_4EC3C_150); 18 | ZZ_JUMPREGISTER_END(); 19 | #endif 20 | ZZ_MARK_TARGET(0x8004AA8C,0x8004AAA8,ZZ_4AA8C); 21 | -------------------------------------------------------------------------------- /srczz/zz_4b6ec.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4B6EC: 3 | V1 = EMU_ReadU32(SP + 16); //+ 0x10 4 | V0 = A0; 5 | EMU_Write16(V0,A1); 6 | EMU_Write16(V0 + 2,A2); //+ 0x2 7 | EMU_Write16(V0 + 4,A3); //+ 0x4 8 | EMU_Write16(V0 + 8,R0); //+ 0x8 9 | EMU_Write16(V0 + 10,R0); //+ 0xA 10 | EMU_Write16(V0 + 12,R0); //+ 0xC 11 | EMU_Write16(V0 + 14,R0); //+ 0xE 12 | EMU_Write8(V0 + 17,R0); //+ 0x11 13 | EMU_Write8(V0 + 16,R0); //+ 0x10 14 | EMU_Write8(V0 + 19,R0); //+ 0x13 15 | EMU_Write8(V0 + 18,R0); //+ 0x12 16 | ZZ_JUMPREGISTER_BEGIN(RA); 17 | EMU_Write16(V0 + 6,V1); //+ 0x6 18 | ZZ_CLOCKCYCLES_JR(15); 19 | ZZ_JUMPREGISTER(0x80016258,ZZ_161D4_84); 20 | ZZ_JUMPREGISTER_END(); 21 | #endif 22 | ZZ_MARK_TARGET(0x8004B6EC,0x8004B728,ZZ_4B6EC); 23 | -------------------------------------------------------------------------------- /src/cdr.c: -------------------------------------------------------------------------------- 1 | #include "cdr.h" 2 | #include "pcsx.h" 3 | 4 | uint8_t CDR_GetStatus(void) 5 | { 6 | return PCSX_Read8(0x1F801800); 7 | } 8 | 9 | void CDR_SetMode(int mode) 10 | { 11 | PCSX_Write8(0x1F801800,mode); 12 | } 13 | 14 | uint8_t CDR_Read(void) 15 | { 16 | return PCSX_Read8(0x1F801802); 17 | } 18 | 19 | uint8_t CDR_ReadResponse(void) 20 | { 21 | return PCSX_Read8(0x1F801801); 22 | } 23 | 24 | uint8_t CDR_Read3(void) 25 | { 26 | return PCSX_Read8(0x1F801803); 27 | } 28 | 29 | void CDR_Write1(uint8_t value) 30 | { 31 | PCSX_Write8(0x1F801801,value); 32 | } 33 | 34 | void CDR_Write2(uint8_t value) 35 | { 36 | PCSX_Write8(0x1F801802,value); 37 | } 38 | 39 | void CDR_Write3(uint8_t value) 40 | { 41 | PCSX_Write8(0x1F801803,value); 42 | } 43 | -------------------------------------------------------------------------------- /srczz/zz_31570.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_31570: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | A2 = EMU_ReadU32(A1); 6 | V0 = EMU_ReadU32(A0); 7 | V1 = EMU_ReadU32(A1 + 8); //+ 0x8 8 | A1 = EMU_ReadU32(A0 + 8); //+ 0x8 9 | A0 = A2 - V0; 10 | RA = 0x80031594; //ZZ_31570_24 11 | A1 = V1 - A1; 12 | ZZ_CLOCKCYCLES(9,0x8004F310); 13 | goto ZZ_4F310; 14 | ZZ_31570_24: 15 | RA = EMU_ReadU32(SP + 16); //+ 0x10 16 | V0 &= 0xFFF; 17 | ZZ_JUMPREGISTER_BEGIN(RA); 18 | SP += 24; 19 | ZZ_CLOCKCYCLES_JR(4); 20 | ZZ_JUMPREGISTER(0x80037A90,ZZ_37930_160); 21 | ZZ_JUMPREGISTER(0x80037AF0,ZZ_37930_1C0); 22 | ZZ_JUMPREGISTER_END(); 23 | #endif 24 | ZZ_MARK_TARGET(0x80031570,0x80031594,ZZ_31570); 25 | ZZ_MARK_TARGET(0x80031594,0x800315A4,ZZ_31570_24); 26 | -------------------------------------------------------------------------------- /srczz/zz_4b854.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4B854: 3 | A2 = 0xFF0000; 4 | A2 |= 0xFFFF; 5 | A3 = 0xFF000000; 6 | V1 = EMU_ReadU32(A1); 7 | V0 = EMU_ReadU32(A0); 8 | V1 &= A3; 9 | V0 &= A2; 10 | V1 |= V0; 11 | EMU_Write32(A1,V1); 12 | V0 = EMU_ReadU32(A0); 13 | A1 &= A2; 14 | V0 &= A3; 15 | V0 |= A1; 16 | ZZ_JUMPREGISTER_BEGIN(RA); 17 | EMU_Write32(A0,V0); 18 | ZZ_CLOCKCYCLES_JR(15); 19 | ZZ_JUMPREGISTER(0x80016D14,ZZ_16C38_DC); 20 | ZZ_JUMPREGISTER(0x80016C28,ZZ_16B90_98); 21 | ZZ_JUMPREGISTER(0x80016EBC,ZZ_16D84_138); 22 | ZZ_JUMPREGISTER(0x80016D68,ZZ_16C38_130); 23 | ZZ_JUMPREGISTER(0x80016F2C,ZZ_16D84_1A8); 24 | ZZ_JUMPREGISTER(0x80016F9C,ZZ_16D84_218); 25 | ZZ_JUMPREGISTER_END(); 26 | #endif 27 | ZZ_MARK_TARGET(0x8004B854,0x8004B890,ZZ_4B854); 28 | -------------------------------------------------------------------------------- /srczz/zz_1402c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_1402C: 3 | V0 = EMU_ReadU32(A0 + 20); //+ 0x14 4 | V1 = 0x1; 5 | EMU_Write16(A0 + 4,V1); //+ 0x4 6 | EMU_Write8(A0 + 15,R0); //+ 0xF 7 | EMU_Write8(A0 + 14,R0); //+ 0xE 8 | V1 = 0x80070000; 9 | V1 = EMU_ReadU32(V1 - 32164); //+ 0xFFFF825C 10 | V0 = (int32_t)V0 >> 1; 11 | V0 <<= 2; 12 | V0 += V1; 13 | V1 = -18; 14 | ZZ_JUMPREGISTER_BEGIN(RA); 15 | EMU_Write32(V0,V1); 16 | ZZ_CLOCKCYCLES_JR(13); 17 | ZZ_JUMPREGISTER(0x80013F58,ZZ_13F14_44); 18 | ZZ_JUMPREGISTER(0x800134F4,ZZ_13304_1F0); 19 | ZZ_JUMPREGISTER(0x800135EC,ZZ_13304_2E8); 20 | ZZ_JUMPREGISTER(0x80012C60,ZZ_12AE4_17C); 21 | ZZ_JUMPREGISTER(0x80014004,ZZ_13FB4_50); 22 | ZZ_JUMPREGISTER_END(); 23 | #endif 24 | ZZ_MARK_TARGET(0x8001402C,0x80014060,ZZ_1402C); 25 | -------------------------------------------------------------------------------- /srczz/zz_36880.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_36880: 3 | SP -= 24; 4 | A1 = A0 << 2; 5 | A1 += A0; 6 | A1 <<= 2; 7 | A1 += A0; 8 | V0 = EMU_ReadU32(GP + 232); //+ 0xE8 9 | A1 <<= 3; 10 | A1 += A0; 11 | A1 <<= 2; 12 | A0 = 0x80060000; 13 | A0 -= 14440; 14 | EMU_Write32(SP + 16,RA); //+ 0x10 15 | A1 += V0; 16 | RA = 0x800368BC; //ZZ_36880_3C 17 | A1 += 1792; 18 | ZZ_CLOCKCYCLES(15,0x8004945C); 19 | goto ZZ_4945C; 20 | ZZ_36880_3C: 21 | RA = EMU_ReadU32(SP + 16); //+ 0x10 22 | V0 = V0 < 1; 23 | ZZ_JUMPREGISTER_BEGIN(RA); 24 | SP += 24; 25 | ZZ_CLOCKCYCLES_JR(4); 26 | ZZ_JUMPREGISTER(0x80036ACC,ZZ_369C4_108); 27 | ZZ_JUMPREGISTER_END(); 28 | #endif 29 | ZZ_MARK_TARGET(0x80036880,0x800368BC,ZZ_36880); 30 | ZZ_MARK_TARGET(0x800368BC,0x800368CC,ZZ_36880_3C); 31 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Function.cs: -------------------------------------------------------------------------------- 1 | namespace PSXDiscompile 2 | { 3 | public enum Function 4 | { 5 | SLL = 0, 6 | SRL = 2, 7 | SRA = 3, 8 | SLLV = 4, 9 | SRLV = 6, 10 | SRAV = 7, 11 | JR = 8, 12 | JALR = 9, 13 | SYSCALL = 12, 14 | BREAK = 13, 15 | MFHI = 16, 16 | MTHI = 17, 17 | MFLO = 18, 18 | MTLO = 19, 19 | MULT = 24, 20 | MULTU = 25, 21 | DIV = 26, 22 | DIVU = 27, 23 | ADD = 32, 24 | ADDU = 33, 25 | SUB = 34, 26 | SUBU = 35, 27 | AND = 36, 28 | OR = 37, 29 | XOR = 38, 30 | NOR = 39, 31 | SLT = 42, 32 | SLTU = 43 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /srczz/zz_27410.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_27410: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,S0); //+ 0x10 5 | S0 = A0; 6 | V0 = -256; 7 | A1 = 0x1; 8 | EMU_Write32(SP + 20,RA); //+ 0x14 9 | EMU_Write32(S0,V0); 10 | RA = 0x80027434; //ZZ_27410_24 11 | EMU_Write32(S0 + 20,R0); //+ 0x14 12 | ZZ_CLOCKCYCLES(9,0x8002744C); 13 | goto ZZ_2744C; 14 | ZZ_27410_24: 15 | EMU_Write32(S0,R0); 16 | RA = EMU_ReadU32(SP + 20); //+ 0x14 17 | S0 = EMU_ReadU32(SP + 16); //+ 0x10 18 | SP += 24; 19 | ZZ_JUMPREGISTER_BEGIN(RA); 20 | ZZ_CLOCKCYCLES_JR(6); 21 | ZZ_JUMPREGISTER(0x80027370,ZZ_27338_38); 22 | ZZ_JUMPREGISTER(0x800273C4,ZZ_27338_8C); 23 | ZZ_JUMPREGISTER_END(); 24 | #endif 25 | ZZ_MARK_TARGET(0x80027410,0x80027434,ZZ_27410); 26 | ZZ_MARK_TARGET(0x80027434,0x8002744C,ZZ_27410_24); 27 | -------------------------------------------------------------------------------- /srczz/zz_471f0.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_471F0: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | A1 = A0; 6 | RA = 0x80047204; //ZZ_471F0_14 7 | A0 = 3; 8 | ZZ_CLOCKCYCLES(5,0x8004A970); 9 | goto ZZ_4A970; 10 | ZZ_471F0_14: 11 | RA = EMU_ReadU32(SP + 16); //+ 0x10 12 | SP += 24; 13 | ZZ_JUMPREGISTER_BEGIN(RA); 14 | ZZ_CLOCKCYCLES_JR(4); 15 | ZZ_JUMPREGISTER(0x80048FA4,ZZ_48F5C_48); 16 | ZZ_JUMPREGISTER(0x800492C0,ZZ_4920C_B4); 17 | ZZ_JUMPREGISTER(0x8004910C,ZZ_48F5C_1B0); 18 | ZZ_JUMPREGISTER(0x80048C00,ZZ_48B90_70); 19 | ZZ_JUMPREGISTER(0x80048C24,ZZ_48B90_94); 20 | ZZ_JUMPREGISTER(0x80048E0C,ZZ_48B90_27C); 21 | ZZ_JUMPREGISTER_END(); 22 | #endif 23 | ZZ_MARK_TARGET(0x800471F0,0x80047204,ZZ_471F0); 24 | ZZ_MARK_TARGET(0x80047204,0x80047214,ZZ_471F0_14); 25 | -------------------------------------------------------------------------------- /srcdisasm/Cutter.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public static class Cutter 6 | { 7 | public static int Cut(int value,int offset,int length,bool unsigned) 8 | { 9 | if (offset < 0) 10 | throw new ArgumentOutOfRangeException("offset"); 11 | if (length <= 0) 12 | throw new ArgumentOutOfRangeException("length"); 13 | if (offset + length > 32) 14 | throw new ArgumentOutOfRangeException(); 15 | value <<= offset; 16 | value >>= 32 - length; 17 | if (unsigned) 18 | { 19 | value &= (1 << length) - 1; 20 | } 21 | return value; 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /srczz/zz_123bc.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_123BC: 3 | V0 = EMU_ReadU32(A0 + 12); //+ 0xC 4 | if (V0) 5 | { 6 | V0 = A1 << 2; 7 | ZZ_CLOCKCYCLES(4,0x800123D4); 8 | goto ZZ_123BC_18; 9 | } 10 | V0 = A1 << 2; 11 | V0 = R0; 12 | ZZ_CLOCKCYCLES(6,0x800123E8); 13 | goto ZZ_123BC_2C; 14 | ZZ_123BC_18: 15 | V0 += A0; 16 | V1 = EMU_ReadU32(V0 + 20); //+ 0x14 17 | V0 = EMU_ReadU32(V0 + 16); //+ 0x10 18 | V0 = V1 - V0; 19 | ZZ_CLOCKCYCLES(5,0x800123E8); 20 | ZZ_123BC_2C: 21 | ZZ_JUMPREGISTER_BEGIN(RA); 22 | ZZ_CLOCKCYCLES_JR(2); 23 | ZZ_JUMPREGISTER(0x80013700,ZZ_13304_3FC); 24 | ZZ_JUMPREGISTER_END(); 25 | #endif 26 | ZZ_MARK_TARGET(0x800123BC,0x800123D4,ZZ_123BC); 27 | ZZ_MARK_TARGET(0x800123D4,0x800123E8,ZZ_123BC_18); 28 | ZZ_MARK_TARGET(0x800123E8,0x800123F0,ZZ_123BC_2C); 29 | -------------------------------------------------------------------------------- /srczz/zz_31080.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_31080: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | A0 = EMU_ReadU32(A0 + 20); //+ 0x14 6 | RA = 0x80031094; //ZZ_31080_14 7 | ZZ_CLOCKCYCLES(5,0x80030FE4); 8 | goto ZZ_30FE4; 9 | ZZ_31080_14: 10 | RA = EMU_ReadU32(SP + 16); //+ 0x10 11 | SP += 24; 12 | ZZ_JUMPREGISTER_BEGIN(RA); 13 | ZZ_CLOCKCYCLES_JR(4); 14 | ZZ_JUMPREGISTER(0x80028D38,ZZ_28C9C_9C); 15 | ZZ_JUMPREGISTER(0x80028A88,ZZ_289C4_C4); 16 | ZZ_JUMPREGISTER(0x80028F9C,ZZ_28EBC_E0); 17 | ZZ_JUMPREGISTER(0x80029378,ZZ_29254_124); 18 | ZZ_JUMPREGISTER(0x800280E0,ZZ_28060_80); 19 | ZZ_JUMPREGISTER(0x80028160,ZZ_28060_100); 20 | ZZ_JUMPREGISTER_END(); 21 | #endif 22 | ZZ_MARK_TARGET(0x80031080,0x80031094,ZZ_31080); 23 | ZZ_MARK_TARGET(0x80031094,0x800310A4,ZZ_31080_14); 24 | -------------------------------------------------------------------------------- /srczz/zz_3636c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_3636C: 3 | V0 = EMU_ReadU32(GP + 232); //+ 0xE8 4 | SP -= 24; 5 | EMU_Write32(SP + 16,RA); //+ 0x10 6 | EMU_Write32(V0 + 8,R0); //+ 0x8 7 | RA = 0x80036384; //ZZ_3636C_18 8 | EMU_Write32(V0 + 20,R0); //+ 0x14 9 | ZZ_CLOCKCYCLES(6,0x800363C8); 10 | goto ZZ_363C8; 11 | ZZ_3636C_18: 12 | RA = EMU_ReadU32(SP + 16); //+ 0x10 13 | V0 = R0; 14 | ZZ_JUMPREGISTER_BEGIN(RA); 15 | SP += 24; 16 | ZZ_CLOCKCYCLES_JR(4); 17 | ZZ_JUMPREGISTER(0x80036680,ZZ_36668_18); 18 | ZZ_JUMPREGISTER(0x80034BA0,ZZ_34B44_5C); 19 | ZZ_JUMPREGISTER(0x80034D20,ZZ_34BCC_154); 20 | ZZ_JUMPREGISTER(0x80034B34,ZZ_34A0C_128); 21 | ZZ_JUMPREGISTER_END(); 22 | #endif 23 | ZZ_MARK_TARGET(0x8003636C,0x80036384,ZZ_3636C); 24 | ZZ_MARK_TARGET(0x80036384,0x80036394,ZZ_3636C_18); 25 | -------------------------------------------------------------------------------- /srczz/zz_36244.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_36244: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | A1 = A0; 6 | A0 = 0x80010000; 7 | A0 += 1692; 8 | RA = 0x80036260; //ZZ_36244_1C 9 | A2 = 0xC; 10 | ZZ_CLOCKCYCLES(7,0x8004946C); 11 | goto ZZ_4946C; 12 | ZZ_36244_1C: 13 | RA = EMU_ReadU32(SP + 16); //+ 0x10 14 | V0 = V0 < 1; 15 | ZZ_JUMPREGISTER_BEGIN(RA); 16 | SP += 24; 17 | ZZ_CLOCKCYCLES_JR(4); 18 | ZZ_JUMPREGISTER(0x80034FCC,ZZ_34F00_CC); 19 | ZZ_JUMPREGISTER(0x800360D8,ZZ_3608C_4C); 20 | ZZ_JUMPREGISTER(0x8003620C,ZZ_361C0_4C); 21 | ZZ_JUMPREGISTER(0x8003598C,ZZ_3578C_200); 22 | ZZ_JUMPREGISTER(0x80036110,ZZ_3608C_84); 23 | ZZ_JUMPREGISTER_END(); 24 | #endif 25 | ZZ_MARK_TARGET(0x80036244,0x80036260,ZZ_36244); 26 | ZZ_MARK_TARGET(0x80036260,0x80036270,ZZ_36244_1C); 27 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/LUIInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class LUIInstruction : Instruction 6 | { 7 | private Register rd; 8 | private int imm; 9 | 10 | public LUIInstruction(Register rd,int imm) 11 | { 12 | this.rd = rd; 13 | this.imm = imm; 14 | } 15 | 16 | public override string ToString() 17 | { 18 | return string.Format("LUI ${0},{1}",rd,imm); 19 | } 20 | 21 | public override void Discompile(Program p,int address,bool direct) 22 | { 23 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 24 | p.WriteLine("{0} = 0x{1:X}0000;",rd,imm); 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /srczz/zz_4a1a4.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A1A4: 3 | V1 = A0 & 0xFFFF; 4 | V0 = (int32_t)V1 < 3; 5 | if (!V0) 6 | { 7 | V0 = 1; 8 | ZZ_CLOCKCYCLES(4,0x8004A1D0); 9 | goto ZZ_4A1A4_2C; 10 | } 11 | V0 = 1; 12 | A0 = 0x80060000; 13 | A0 = EMU_ReadU32(A0 - 12828); //+ 0xFFFFCDE4 14 | V1 <<= 4; 15 | V1 += A0; 16 | EMU_Write16(V1,R0); 17 | ZZ_CLOCKCYCLES(11,0x8004A1D4); 18 | goto ZZ_4A1A4_30; 19 | ZZ_4A1A4_2C: 20 | V0 = R0; 21 | ZZ_CLOCKCYCLES(1,0x8004A1D4); 22 | ZZ_4A1A4_30: 23 | ZZ_JUMPREGISTER_BEGIN(RA); 24 | ZZ_CLOCKCYCLES_JR(2); 25 | ZZ_JUMPREGISTER(0x80055034,ZZ_54E64_1D0); 26 | ZZ_JUMPREGISTER_END(); 27 | #endif 28 | ZZ_MARK_TARGET(0x8004A1A4,0x8004A1D0,ZZ_4A1A4); 29 | ZZ_MARK_TARGET(0x8004A1D0,0x8004A1D4,ZZ_4A1A4_2C); 30 | ZZ_MARK_TARGET(0x8004A1D4,0x8004A1DC,ZZ_4A1A4_30); 31 | -------------------------------------------------------------------------------- /srczz/zz_4a9a0.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A9A0: 3 | SP -= 24; 4 | V0 = 0x80060000; 5 | V0 = EMU_ReadU32(V0 - 8452); //+ 0xFFFFDEFC 6 | A1 = A0; 7 | EMU_Write32(SP + 16,RA); //+ 0x10 8 | V0 = EMU_ReadU32(V0 + 20); //+ 0x14 9 | ZZ_JUMPREGISTER_BEGIN(V0); 10 | RA = 0x8004A9C4; //ZZ_4A9A0_24 11 | A0 = 4; 12 | ZZ_CLOCKCYCLES_JR(9); 13 | // UNIMPLEMENTED JUMP-TO-REGISTER-AND-LINK (V0,8004A9BC) 14 | ZZ_JUMPREGISTER_END(); 15 | ZZ_4A9A0_24: 16 | RA = EMU_ReadU32(SP + 16); //+ 0x10 17 | SP += 24; 18 | ZZ_JUMPREGISTER_BEGIN(RA); 19 | ZZ_CLOCKCYCLES_JR(4); 20 | ZZ_JUMPREGISTER(0x80052E6C,ZZ_52E18_54); 21 | ZZ_JUMPREGISTER(0x8005501C,ZZ_54E64_1B8); 22 | ZZ_JUMPREGISTER_END(); 23 | #endif 24 | ZZ_MARK_TARGET(0x8004A9A0,0x8004A9C4,ZZ_4A9A0); 25 | ZZ_MARK_TARGET(0x8004A9C4,0x8004A9D4,ZZ_4A9A0_24); 26 | -------------------------------------------------------------------------------- /srczz/zz_4aff4.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4AFF4: 3 | SP -= 8; 4 | if (!A1) 5 | { 6 | V0 = A1 - 1; 7 | ZZ_CLOCKCYCLES(3,0x8004B014); 8 | goto ZZ_4AFF4_20; 9 | } 10 | V0 = A1 - 1; 11 | V1 = -1; 12 | ZZ_CLOCKCYCLES(4,0x8004B004); 13 | ZZ_4AFF4_10: 14 | EMU_Write32(A0,R0); 15 | V0 -= 1; 16 | if (V0 != V1) 17 | { 18 | A0 += 4; 19 | ZZ_CLOCKCYCLES(4,0x8004B004); 20 | goto ZZ_4AFF4_10; 21 | } 22 | A0 += 4; 23 | ZZ_CLOCKCYCLES(4,0x8004B014); 24 | ZZ_4AFF4_20: 25 | SP += 8; 26 | ZZ_JUMPREGISTER_BEGIN(RA); 27 | ZZ_CLOCKCYCLES_JR(3); 28 | ZZ_JUMPREGISTER(0x8004AB08,ZZ_4AAA8_60); 29 | ZZ_JUMPREGISTER_END(); 30 | #endif 31 | ZZ_MARK_TARGET(0x8004AFF4,0x8004B004,ZZ_4AFF4); 32 | ZZ_MARK_TARGET(0x8004B004,0x8004B014,ZZ_4AFF4_10); 33 | ZZ_MARK_TARGET(0x8004B014,0x8004B020,ZZ_4AFF4_20); 34 | -------------------------------------------------------------------------------- /srczz/zz_4b17c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4B17C: 3 | SP -= 8; 4 | if (!A1) 5 | { 6 | V0 = A1 - 1; 7 | ZZ_CLOCKCYCLES(3,0x8004B19C); 8 | goto ZZ_4B17C_20; 9 | } 10 | V0 = A1 - 1; 11 | V1 = -1; 12 | ZZ_CLOCKCYCLES(4,0x8004B18C); 13 | ZZ_4B17C_10: 14 | EMU_Write32(A0,R0); 15 | V0 -= 1; 16 | if (V0 != V1) 17 | { 18 | A0 += 4; 19 | ZZ_CLOCKCYCLES(4,0x8004B18C); 20 | goto ZZ_4B17C_10; 21 | } 22 | A0 += 4; 23 | ZZ_CLOCKCYCLES(4,0x8004B19C); 24 | ZZ_4B17C_20: 25 | SP += 8; 26 | ZZ_JUMPREGISTER_BEGIN(RA); 27 | ZZ_CLOCKCYCLES_JR(3); 28 | ZZ_JUMPREGISTER(0x8004B0B0,ZZ_4B080_30); 29 | ZZ_JUMPREGISTER_END(); 30 | #endif 31 | ZZ_MARK_TARGET(0x8004B17C,0x8004B18C,ZZ_4B17C); 32 | ZZ_MARK_TARGET(0x8004B18C,0x8004B19C,ZZ_4B17C_10); 33 | ZZ_MARK_TARGET(0x8004B19C,0x8004B1A8,ZZ_4B17C_20); 34 | -------------------------------------------------------------------------------- /srczz/zz_4b424.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4B424: 3 | SP -= 8; 4 | if (!A1) 5 | { 6 | V0 = A1 - 1; 7 | ZZ_CLOCKCYCLES(3,0x8004B444); 8 | goto ZZ_4B424_20; 9 | } 10 | V0 = A1 - 1; 11 | V1 = -1; 12 | ZZ_CLOCKCYCLES(4,0x8004B434); 13 | ZZ_4B424_10: 14 | EMU_Write32(A0,R0); 15 | V0 -= 1; 16 | if (V0 != V1) 17 | { 18 | A0 += 4; 19 | ZZ_CLOCKCYCLES(4,0x8004B434); 20 | goto ZZ_4B424_10; 21 | } 22 | A0 += 4; 23 | ZZ_CLOCKCYCLES(4,0x8004B444); 24 | ZZ_4B424_20: 25 | SP += 8; 26 | ZZ_JUMPREGISTER_BEGIN(RA); 27 | ZZ_CLOCKCYCLES_JR(3); 28 | ZZ_JUMPREGISTER(0x8004B1C0,ZZ_4B1A8_18); 29 | ZZ_JUMPREGISTER_END(); 30 | #endif 31 | ZZ_MARK_TARGET(0x8004B424,0x8004B434,ZZ_4B424); 32 | ZZ_MARK_TARGET(0x8004B434,0x8004B444,ZZ_4B424_10); 33 | ZZ_MARK_TARGET(0x8004B444,0x8004B450,ZZ_4B424_20); 34 | -------------------------------------------------------------------------------- /src/dma.h: -------------------------------------------------------------------------------- 1 | #ifndef H_DMA_H 2 | #define H_DMA_H 3 | 4 | #include "common.h" 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | enum 11 | { 12 | DMA_MDEC_IN, 13 | DMA_MDEC_OUT, 14 | DMA_GPU, 15 | DMA_CDR, 16 | DMA_SPU, 17 | DMA_PIO, 18 | DMA_OTC, 19 | DMA__COUNT 20 | }; 21 | 22 | extern void DMA_SetAddress(int channel,uint32_t value); 23 | extern void DMA_SetBlockData(int channel,uint32_t value); 24 | 25 | extern uint32_t DMA_GetMode(int channel); 26 | extern void DMA_SetMode(int channel,uint32_t value); 27 | 28 | extern uint32_t DMA_GetControlRegister(void); 29 | extern void DMA_SetControlRegister(uint32_t value); 30 | extern uint32_t DMA_GetInterruptRegister(void); 31 | extern void DMA_SetInterruptRegister(uint32_t value); 32 | 33 | #ifdef __cplusplus 34 | } 35 | #endif 36 | 37 | #endif 38 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Multiply/DIVInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class DIVInstruction : Instruction 6 | { 7 | private Register rs; 8 | private Register rt; 9 | 10 | public DIVInstruction(Register rs,Register rt) 11 | { 12 | this.rs = rs; 13 | this.rt = rt; 14 | } 15 | 16 | public override string ToString() 17 | { 18 | return string.Format("DIV ${0},${1}",rs,rt); 19 | } 20 | 21 | public override void Discompile(Program p,int address,bool direct) 22 | { 23 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 24 | p.WriteLine("EMU_SDivide({0},{1});",rs,rt); 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Multiply/DIVUInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class DIVUInstruction : Instruction 6 | { 7 | private Register rs; 8 | private Register rt; 9 | 10 | public DIVUInstruction(Register rs,Register rt) 11 | { 12 | this.rs = rs; 13 | this.rt = rt; 14 | } 15 | 16 | public override string ToString() 17 | { 18 | return string.Format("DIVU ${0},${1}",rs,rt); 19 | } 20 | 21 | public override void Discompile(Program p,int address,bool direct) 22 | { 23 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 24 | p.WriteLine("EMU_UDivide({0},{1});",rs,rt); 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Register.cs: -------------------------------------------------------------------------------- 1 | namespace PSXDiscompile 2 | { 3 | public enum Register 4 | { 5 | R0 = 0, 6 | AT = 1, 7 | V0 = 2, 8 | V1 = 3, 9 | A0 = 4, 10 | A1 = 5, 11 | A2 = 6, 12 | A3 = 7, 13 | T0 = 8, 14 | T1 = 9, 15 | T2 = 10, 16 | T3 = 11, 17 | T4 = 12, 18 | T5 = 13, 19 | T6 = 14, 20 | T7 = 15, 21 | S0 = 16, 22 | S1 = 17, 23 | S2 = 18, 24 | S3 = 19, 25 | S4 = 20, 26 | S5 = 21, 27 | S6 = 22, 28 | S7 = 23, 29 | T8 = 24, 30 | T9 = 25, 31 | K0 = 26, 32 | K1 = 27, 33 | GP = 28, 34 | SP = 29, 35 | FP = 30, 36 | RA = 31 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Multiply/MULTInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class MULTInstruction : Instruction 6 | { 7 | private Register rs; 8 | private Register rt; 9 | 10 | public MULTInstruction(Register rs,Register rt) 11 | { 12 | this.rs = rs; 13 | this.rt = rt; 14 | } 15 | 16 | public override string ToString() 17 | { 18 | return string.Format("MULT ${0},${1}",rs,rt); 19 | } 20 | 21 | public override void Discompile(Program p,int address,bool direct) 22 | { 23 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 24 | p.WriteLine("EMU_SMultiply({0},{1});",rs,rt); 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /srczz/zz_5b290.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_5B290: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,S0); //+ 0x10 5 | EMU_Write32(SP + 20,RA); //+ 0x14 6 | RA = 0x8005B2A4; //ZZ_5B290_14 7 | S0 = A0; 8 | ZZ_CLOCKCYCLES(5,0x8005B280); 9 | goto ZZ_5B280; 10 | ZZ_5B290_14: 11 | A0 = S0; 12 | A1 = 63; 13 | RA = 0x8005B2B4; //ZZ_5B290_24 14 | A2 = R0; 15 | ZZ_CLOCKCYCLES(4,0x8005B260); 16 | goto ZZ_5B260; 17 | ZZ_5B290_24: 18 | RA = EMU_ReadU32(SP + 20); //+ 0x14 19 | S0 = EMU_ReadU32(SP + 16); //+ 0x10 20 | SP += 24; 21 | ZZ_JUMPREGISTER_BEGIN(RA); 22 | ZZ_CLOCKCYCLES_JR(5); 23 | ZZ_JUMPREGISTER(0x80034ADC,ZZ_34A0C_D0); 24 | ZZ_JUMPREGISTER_END(); 25 | #endif 26 | ZZ_MARK_TARGET(0x8005B290,0x8005B2A4,ZZ_5B290); 27 | ZZ_MARK_TARGET(0x8005B2A4,0x8005B2B4,ZZ_5B290_14); 28 | ZZ_MARK_TARGET(0x8005B2B4,0x8005B2C8,ZZ_5B290_24); 29 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Multiply/MULTUInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class MULTUInstruction : Instruction 6 | { 7 | private Register rs; 8 | private Register rt; 9 | 10 | public MULTUInstruction(Register rs,Register rt) 11 | { 12 | this.rs = rs; 13 | this.rt = rt; 14 | } 15 | 16 | public override string ToString() 17 | { 18 | return string.Format("MULTU ${0},${1}",rs,rt); 19 | } 20 | 21 | public override void Discompile(Program p,int address,bool direct) 22 | { 23 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 24 | p.WriteLine("EMU_UMultiply({0},{1});",rs,rt); 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /srczz/zz_29a3c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_29A3C: 3 | A0 = 0x80060000; 4 | A0 = EMU_ReadU32(A0 - 2456); //+ 0xFFFFF668 5 | SP -= 24; 6 | EMU_Write32(SP + 16,RA); //+ 0x10 7 | RA = 0x80029A54; //ZZ_29A3C_18 8 | ZZ_CLOCKCYCLES(6,0x800116C0); 9 | goto ZZ_116C0; 10 | ZZ_29A3C_18: 11 | A0 = 0x80060000; 12 | A0 = EMU_ReadU32(A0 - 2512); //+ 0xFFFFF630 13 | RA = 0x80029A64; //ZZ_29A3C_28 14 | ZZ_CLOCKCYCLES(4,0x800116C0); 15 | goto ZZ_116C0; 16 | ZZ_29A3C_28: 17 | RA = EMU_ReadU32(SP + 16); //+ 0x10 18 | V0 = -255; 19 | ZZ_JUMPREGISTER_BEGIN(RA); 20 | SP += 24; 21 | ZZ_CLOCKCYCLES_JR(4); 22 | ZZ_JUMPREGISTER(0x800153E0,ZZ_15340_A0); 23 | ZZ_JUMPREGISTER_END(); 24 | #endif 25 | ZZ_MARK_TARGET(0x80029A3C,0x80029A54,ZZ_29A3C); 26 | ZZ_MARK_TARGET(0x80029A54,0x80029A64,ZZ_29A3C_18); 27 | ZZ_MARK_TARGET(0x80029A64,0x80029A74,ZZ_29A3C_28); 28 | -------------------------------------------------------------------------------- /srczz/zz_58e2c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_58E2C: 3 | SP -= 24; 4 | A1 = 0xFF0000; 5 | A1 |= 0xFFFF; 6 | A0 &= 0xFF; 7 | V0 = A0 << 3; 8 | V0 = V0 - A0; 9 | V0 <<= 2; 10 | V0 = V0 - A0; 11 | V0 <<= 1; 12 | EMU_Write32(SP + 16,RA); //+ 0x10 13 | AT = 0x80060000; 14 | AT += V0; 15 | EMU_Write16(AT + 1192,R0); //+ 0x4A8 16 | AT = 0x80060000; 17 | AT += V0; 18 | EMU_Write8(AT + 1217,R0); //+ 0x4C1 19 | RA = 0x80058E74; //ZZ_58E2C_48 20 | A0 = R0; 21 | ZZ_CLOCKCYCLES(18,0x800576FC); 22 | goto ZZ_576FC; 23 | ZZ_58E2C_48: 24 | RA = EMU_ReadU32(SP + 16); //+ 0x10 25 | SP += 24; 26 | ZZ_JUMPREGISTER_BEGIN(RA); 27 | ZZ_CLOCKCYCLES_JR(4); 28 | ZZ_JUMPREGISTER(0x80058118,ZZ_58030_E8); 29 | ZZ_JUMPREGISTER_END(); 30 | #endif 31 | ZZ_MARK_TARGET(0x80058E2C,0x80058E74,ZZ_58E2C); 32 | ZZ_MARK_TARGET(0x80058E74,0x80058E84,ZZ_58E2C_48); 33 | -------------------------------------------------------------------------------- /srczz/zz_52fc4.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_52FC4: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | RA = 0x80052FD4; //ZZ_52FC4_10 6 | ZZ_CLOCKCYCLES(4,0x8004A910); 7 | goto ZZ_4A910; 8 | ZZ_52FC4_10: 9 | RA = 0x80052FDC; //ZZ_52FC4_18 10 | ZZ_CLOCKCYCLES(2,0x80052FF4); 11 | goto ZZ_52FF4; 12 | ZZ_52FC4_18: 13 | RA = 0x80052FE4; //ZZ_52FC4_20 14 | ZZ_CLOCKCYCLES(2,0x80052EDC); 15 | goto ZZ_52EDC; 16 | ZZ_52FC4_20: 17 | RA = EMU_ReadU32(SP + 16); //+ 0x10 18 | SP += 24; 19 | ZZ_JUMPREGISTER_BEGIN(RA); 20 | ZZ_CLOCKCYCLES_JR(4); 21 | ZZ_JUMPREGISTER(0x800327FC,ZZ_327B4_48); 22 | ZZ_JUMPREGISTER_END(); 23 | #endif 24 | ZZ_MARK_TARGET(0x80052FC4,0x80052FD4,ZZ_52FC4); 25 | ZZ_MARK_TARGET(0x80052FD4,0x80052FDC,ZZ_52FC4_10); 26 | ZZ_MARK_TARGET(0x80052FDC,0x80052FE4,ZZ_52FC4_18); 27 | ZZ_MARK_TARGET(0x80052FE4,0x80052FF4,ZZ_52FC4_20); 28 | -------------------------------------------------------------------------------- /srczz/zz_36394.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_36394: 3 | A0 = R0; 4 | V1 = R0; 5 | ZZ_CLOCKCYCLES(2,0x8003639C); 6 | ZZ_36394_8: 7 | V0 = EMU_ReadU32(GP + 232); //+ 0xE8 8 | if (!V0) 9 | { 10 | V0 += V1; 11 | ZZ_CLOCKCYCLES(4,0x800363B0); 12 | goto ZZ_36394_1C; 13 | } 14 | V0 += V1; 15 | EMU_Write8(V0 + 52,R0); //+ 0x34 16 | ZZ_CLOCKCYCLES(5,0x800363B0); 17 | ZZ_36394_1C: 18 | A0 += 1; 19 | V0 = (int32_t)A0 < 15; 20 | if (V0) 21 | { 22 | V1 += 76; 23 | ZZ_CLOCKCYCLES(4,0x8003639C); 24 | goto ZZ_36394_8; 25 | } 26 | V1 += 76; 27 | ZZ_JUMPREGISTER_BEGIN(RA); 28 | ZZ_CLOCKCYCLES_JR(6); 29 | ZZ_JUMPREGISTER(0x80034CC0,ZZ_34BCC_F4); 30 | ZZ_JUMPREGISTER_END(); 31 | #endif 32 | ZZ_MARK_TARGET(0x80036394,0x8003639C,ZZ_36394); 33 | ZZ_MARK_TARGET(0x8003639C,0x800363B0,ZZ_36394_8); 34 | ZZ_MARK_TARGET(0x800363B0,0x800363C8,ZZ_36394_1C); 35 | -------------------------------------------------------------------------------- /srczz/zz_4a334.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A334: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | RA = 0x8004A344; //ZZ_4A334_10 6 | ZZ_CLOCKCYCLES(4,0x8004A50C); 7 | goto ZZ_4A50C; 8 | ZZ_4A334_10: 9 | RA = 0x8004A34C; //ZZ_4A334_18 10 | A0 = R0; 11 | ZZ_CLOCKCYCLES(2,0x8004A054); 12 | goto ZZ_4A054; 13 | ZZ_4A334_18: 14 | RA = 0x8004A354; //ZZ_4A334_20 15 | ZZ_CLOCKCYCLES(2,0x8004A55C); 16 | goto ZZ_4A55C; 17 | ZZ_4A334_20: 18 | RA = EMU_ReadU32(SP + 16); //+ 0x10 19 | SP += 24; 20 | ZZ_JUMPREGISTER_BEGIN(RA); 21 | ZZ_CLOCKCYCLES_JR(4); 22 | ZZ_JUMPREGISTER(0x800159C4,ZZ_1594C_78); 23 | ZZ_JUMPREGISTER_END(); 24 | #endif 25 | ZZ_MARK_TARGET(0x8004A334,0x8004A344,ZZ_4A334); 26 | ZZ_MARK_TARGET(0x8004A344,0x8004A34C,ZZ_4A334_10); 27 | ZZ_MARK_TARGET(0x8004A34C,0x8004A354,ZZ_4A334_18); 28 | ZZ_MARK_TARGET(0x8004A354,0x8004A364,ZZ_4A334_20); 29 | -------------------------------------------------------------------------------- /srczz/zz_4a970.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A970: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU32(V0 - 8452); //+ 0xFFFFDEFC 5 | SP -= 24; 6 | EMU_Write32(SP + 16,RA); //+ 0x10 7 | V0 = EMU_ReadU32(V0 + 4); //+ 0x4 8 | ZZ_JUMPREGISTER_BEGIN(V0); 9 | RA = 0x8004A990; //ZZ_4A970_20 10 | ZZ_CLOCKCYCLES_JR(8); 11 | // UNIMPLEMENTED JUMP-TO-REGISTER-AND-LINK (V0,8004A988) 12 | ZZ_JUMPREGISTER_END(); 13 | ZZ_4A970_20: 14 | RA = EMU_ReadU32(SP + 16); //+ 0x10 15 | SP += 24; 16 | ZZ_JUMPREGISTER_BEGIN(RA); 17 | ZZ_CLOCKCYCLES_JR(4); 18 | ZZ_JUMPREGISTER(0x80050314,ZZ_50300_14); 19 | ZZ_JUMPREGISTER(0x80047204,ZZ_471F0_14); 20 | ZZ_JUMPREGISTER(0x8004E4F0,ZZ_4E398_158); 21 | ZZ_JUMPREGISTER(0x8004E72C,ZZ_4E678_B4); 22 | ZZ_JUMPREGISTER_END(); 23 | #endif 24 | ZZ_MARK_TARGET(0x8004A970,0x8004A990,ZZ_4A970); 25 | ZZ_MARK_TARGET(0x8004A990,0x8004A9A0,ZZ_4A970_20); 26 | -------------------------------------------------------------------------------- /srczz/zz_4ec08.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4EC08: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | RA = 0x8004EC18; //ZZ_4EC08_10 6 | A0 = -1; 7 | ZZ_CLOCKCYCLES(4,0x8004A71C); 8 | goto ZZ_4A71C; 9 | ZZ_4EC08_10: 10 | V0 += 240; 11 | AT = 0x80060000; 12 | EMU_Write32(AT - 7988,V0); //+ 0xFFFFE0CC 13 | AT = 0x80060000; 14 | EMU_Write32(AT - 7984,R0); //+ 0xFFFFE0D0 15 | RA = EMU_ReadU32(SP + 16); //+ 0x10 16 | SP += 24; 17 | ZZ_JUMPREGISTER_BEGIN(RA); 18 | ZZ_CLOCKCYCLES_JR(9); 19 | ZZ_JUMPREGISTER(0x8004EAD8,ZZ_4EAC0_18); 20 | ZZ_JUMPREGISTER(0x8004E010,ZZ_4DFE8_28); 21 | ZZ_JUMPREGISTER(0x8004E3C4,ZZ_4E398_2C); 22 | ZZ_JUMPREGISTER(0x8004DDD8,ZZ_4DDAC_2C); 23 | ZZ_JUMPREGISTER(0x8004DAE4,ZZ_4DA68_7C); 24 | ZZ_JUMPREGISTER_END(); 25 | #endif 26 | ZZ_MARK_TARGET(0x8004EC08,0x8004EC18,ZZ_4EC08); 27 | ZZ_MARK_TARGET(0x8004EC18,0x8004EC3C,ZZ_4EC08_10); 28 | -------------------------------------------------------------------------------- /srczz/zz_47338.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_47338: 3 | V1 = EMU_ReadU8(A0); 4 | A2 = EMU_ReadU8(A0 + 1); //+ 0x1 5 | A1 = V1 >> 4; 6 | V0 = A1 << 2; 7 | V0 += A1; 8 | V0 <<= 1; 9 | V1 &= 0xF; 10 | V0 += V1; 11 | A1 = V0 << 4; 12 | A1 = A1 - V0; 13 | A1 <<= 2; 14 | V1 = A2 >> 4; 15 | V0 = V1 << 2; 16 | V0 += V1; 17 | V0 <<= 1; 18 | A2 &= 0xF; 19 | V0 += A2; 20 | A1 += V0; 21 | V1 = A1 << 2; 22 | V1 += A1; 23 | V0 = V1 << 4; 24 | A1 = EMU_ReadU8(A0 + 2); //+ 0x2 25 | V0 = V0 - V1; 26 | A0 = A1 >> 4; 27 | V1 = A0 << 2; 28 | V1 += A0; 29 | V1 <<= 1; 30 | A1 &= 0xF; 31 | V1 += A1; 32 | V0 += V1; 33 | ZZ_JUMPREGISTER_BEGIN(RA); 34 | V0 -= 150; 35 | ZZ_CLOCKCYCLES_JR(32); 36 | ZZ_JUMPREGISTER(0x800490CC,ZZ_48F5C_170); 37 | ZZ_JUMPREGISTER(0x80048C3C,ZZ_48B90_AC); 38 | ZZ_JUMPREGISTER_END(); 39 | #endif 40 | ZZ_MARK_TARGET(0x80047338,0x800473B8,ZZ_47338); 41 | -------------------------------------------------------------------------------- /srczz/zz_4d8d8.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4D8D8: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU8(V0 - 8268); //+ 0xFFFFDFB4 5 | V0 -= 1; 6 | V0 = V0 < 2; 7 | if (V0) 8 | { 9 | V1 = A1 & 0xFFF; 10 | ZZ_CLOCKCYCLES(7,0x8004D904); 11 | goto ZZ_4D8D8_2C; 12 | } 13 | V1 = A1 & 0xFFF; 14 | V1 = A1 & 0x7FF; 15 | V1 <<= 11; 16 | V0 = A0 & 0x7FF; 17 | ZZ_CLOCKCYCLES(11,0x8004D90C); 18 | goto ZZ_4D8D8_34; 19 | ZZ_4D8D8_2C: 20 | V1 <<= 12; 21 | V0 = A0 & 0xFFF; 22 | ZZ_CLOCKCYCLES(2,0x8004D90C); 23 | ZZ_4D8D8_34: 24 | A0 = 0xE5000000; 25 | V0 |= A0; 26 | ZZ_JUMPREGISTER_BEGIN(RA); 27 | V0 |= V1; 28 | ZZ_CLOCKCYCLES_JR(4); 29 | ZZ_JUMPREGISTER(0x8004D4CC,ZZ_4D458_74); 30 | ZZ_JUMPREGISTER_END(); 31 | #endif 32 | ZZ_MARK_TARGET(0x8004D8D8,0x8004D904,ZZ_4D8D8); 33 | ZZ_MARK_TARGET(0x8004D904,0x8004D90C,ZZ_4D8D8_2C); 34 | ZZ_MARK_TARGET(0x8004D90C,0x8004D91C,ZZ_4D8D8_34); 35 | -------------------------------------------------------------------------------- /srczz/zz_54e14.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_54E14: 3 | SP -= 64; 4 | V0 = 3; 5 | A0 <<= 16; 6 | A0 = (int32_t)A0 >> 16; 7 | EMU_Write32(SP + 16,V0); //+ 0x10 8 | V0 = A0 << 7; 9 | V0 += A0; 10 | A1 <<= 16; 11 | A1 = (int32_t)A1 >> 16; 12 | EMU_Write16(SP + 20,V0); //+ 0x14 13 | V0 = A1 << 7; 14 | V0 += A1; 15 | A0 = SP + 16; 16 | EMU_Write32(SP + 56,RA); //+ 0x38 17 | RA = 0x80054E54; //ZZ_54E14_40 18 | EMU_Write16(SP + 22,V0); //+ 0x16 19 | ZZ_CLOCKCYCLES(16,0x80051670); 20 | goto ZZ_51670; 21 | ZZ_54E14_40: 22 | RA = EMU_ReadU32(SP + 56); //+ 0x38 23 | SP += 64; 24 | ZZ_JUMPREGISTER_BEGIN(RA); 25 | ZZ_CLOCKCYCLES_JR(4); 26 | ZZ_JUMPREGISTER(0x8003287C,ZZ_327B4_C8); 27 | ZZ_JUMPREGISTER(0x800338EC,ZZ_337BC_130); 28 | ZZ_JUMPREGISTER_END(); 29 | #endif 30 | ZZ_MARK_TARGET(0x80054E14,0x80054E54,ZZ_54E14); 31 | ZZ_MARK_TARGET(0x80054E54,0x80054E64,ZZ_54E14_40); 32 | -------------------------------------------------------------------------------- /srczz/zz_20178.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_20178: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU32(V0 + 2916); //+ 0xB64 5 | SP -= 32; 6 | EMU_Write32(SP + 16,S0); //+ 0x10 7 | S0 = 0x80060000; 8 | S0 += 2920; 9 | EMU_Write32(SP + 24,RA); //+ 0x18 10 | EMU_Write32(SP + 20,S1); //+ 0x14 11 | S1 = EMU_ReadU32(S0); 12 | RA = 0x800201A4; //ZZ_20178_2C 13 | EMU_Write32(S0,V0); 14 | ZZ_CLOCKCYCLES(11,0x80020290); 15 | goto ZZ_20290; 16 | ZZ_20178_2C: 17 | V0 = -255; 18 | EMU_Write32(S0,S1); 19 | RA = EMU_ReadU32(SP + 24); //+ 0x18 20 | S1 = EMU_ReadU32(SP + 20); //+ 0x14 21 | S0 = EMU_ReadU32(SP + 16); //+ 0x10 22 | SP += 32; 23 | ZZ_JUMPREGISTER_BEGIN(RA); 24 | ZZ_CLOCKCYCLES_JR(8); 25 | ZZ_JUMPREGISTER(0x80012C38,ZZ_12AE4_154); 26 | ZZ_JUMPREGISTER_END(); 27 | #endif 28 | ZZ_MARK_TARGET(0x80020178,0x800201A4,ZZ_20178); 29 | ZZ_MARK_TARGET(0x800201A4,0x800201C4,ZZ_20178_2C); 30 | -------------------------------------------------------------------------------- /srczz/zz_23ff0.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_23FF0: 3 | A0 = 0x80060000; 4 | A0 = EMU_ReadU32(A0 + 2924); //+ 0xB6C 5 | A2 = 0x80060000; 6 | A2 = EMU_ReadU32(A2 + 2936); //+ 0xB78 7 | SP -= 40; 8 | V0 = 0x3; 9 | EMU_Write32(SP + 20,V0); //+ 0x14 10 | V0 = 0x120; 11 | A1 = 0x130; 12 | A3 = R0; 13 | EMU_Write32(SP + 32,RA); //+ 0x20 14 | EMU_Write32(SP + 16,R0); //+ 0x10 15 | RA = 0x80024028; //ZZ_23FF0_38 16 | EMU_Write32(SP + 24,V0); //+ 0x18 17 | ZZ_CLOCKCYCLES(14,0x800324E0); 18 | goto ZZ_324E0; 19 | ZZ_23FF0_38: 20 | RA = EMU_ReadU32(SP + 32); //+ 0x20 21 | SP += 40; 22 | ZZ_JUMPREGISTER_BEGIN(RA); 23 | ZZ_CLOCKCYCLES_JR(4); 24 | ZZ_JUMPREGISTER(0x80016FA4,ZZ_16D84_220); 25 | ZZ_JUMPREGISTER(0x80020AD0,ZZ_20304_7CC); 26 | ZZ_JUMPREGISTER_END(); 27 | #endif 28 | ZZ_MARK_TARGET(0x80023FF0,0x80024028,ZZ_23FF0); 29 | ZZ_MARK_TARGET(0x80024028,0x80024038,ZZ_23FF0_38); 30 | -------------------------------------------------------------------------------- /srczz/zz_4398c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4398C: 3 | S4 = EMU_ReadU32(SP + 40); //+ 0x28 4 | S5 = EMU_ReadU32(SP + 44); //+ 0x2C 5 | S7 = EMU_ReadU32(V1 + 20); //+ 0x14 6 | T9 = EMU_ReadU32(S4); 7 | T2 = 0xFFFE0000; 8 | T2 |= 0xFFFF; 9 | T1 = 0xFF0000; 10 | T1 |= 0xFF; 11 | A0 = EMU_ReadU32(S4 + 4); //+ 0x4 12 | A1 = EMU_ReadU32(S5); 13 | A2 = EMU_ReadU32(S5 + 4); //+ 0x4 14 | T9 += A1; 15 | A1 = T9 << 16; 16 | A1 = (int32_t)A1 >> 17; 17 | A1 &= 0xFFFF; 18 | T9 = (int32_t)T9 >> 17; 19 | T9 <<= 16; 20 | T9 |= A1; 21 | A0 += A2; 22 | A0 = (int32_t)A0 >> 1; 23 | EMU_Write32(V1 + 280,T9); //+ 0x118 24 | ZZ_JUMPREGISTER_BEGIN(T8); 25 | EMU_Write32(V1 + 284,A0); //+ 0x11C 26 | ZZ_CLOCKCYCLES_JR(23); 27 | // UNIMPLEMENTED INDIRECT JUMP (T8,800439E0) 28 | // PC IS 800439E0 29 | ZZ_JUMPREGISTER_END(); 30 | #endif 31 | ZZ_MARK_TARGET(0x8004398C,0x800439E8,ZZ_4398C); 32 | -------------------------------------------------------------------------------- /srczz/zz_51590.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_51590: 3 | if (!A0) 4 | { 5 | V0 = 1; 6 | ZZ_CLOCKCYCLES(2,0x800515A8); 7 | goto ZZ_51590_18; 8 | } 9 | V0 = 1; 10 | if (A0 != V0) 11 | { 12 | V0 = R0; 13 | ZZ_CLOCKCYCLES(4,0x800515AC); 14 | goto ZZ_51590_1C; 15 | } 16 | V0 = R0; 17 | V0 = 1; 18 | ZZ_CLOCKCYCLES(6,0x800515AC); 19 | goto ZZ_51590_1C; 20 | ZZ_51590_18: 21 | V0 = R0; 22 | ZZ_CLOCKCYCLES(1,0x800515AC); 23 | ZZ_51590_1C: 24 | AT = 0x80060000; 25 | EMU_Write32(AT - 5400,A0); //+ 0xFFFFEAE8 26 | AT = 0x80060000; 27 | ZZ_JUMPREGISTER_BEGIN(RA); 28 | EMU_Write32(AT - 5500,V0); //+ 0xFFFFEA84 29 | ZZ_CLOCKCYCLES_JR(5); 30 | ZZ_JUMPREGISTER(0x80032840,ZZ_327B4_8C); 31 | ZZ_JUMPREGISTER_END(); 32 | #endif 33 | ZZ_MARK_TARGET(0x80051590,0x800515A8,ZZ_51590); 34 | ZZ_MARK_TARGET(0x800515A8,0x800515AC,ZZ_51590_18); 35 | ZZ_MARK_TARGET(0x800515AC,0x800515C0,ZZ_51590_1C); 36 | -------------------------------------------------------------------------------- /srczz/zz_58ddc.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_58DDC: 3 | V0 = A0; 4 | if ((int32_t)V0 < 0) 5 | { 6 | A1 = R0; 7 | ZZ_CLOCKCYCLES(3,0x80058DFC); 8 | goto ZZ_58DDC_20; 9 | } 10 | A1 = R0; 11 | A1 = V0; 12 | V0 = (int32_t)A1 < 64; 13 | if (V0) 14 | { 15 | ZZ_CLOCKCYCLES(7,0x80058DFC); 16 | goto ZZ_58DDC_20; 17 | } 18 | A1 = 63; 19 | ZZ_CLOCKCYCLES(8,0x80058DFC); 20 | ZZ_58DDC_20: 21 | A0 = 0x80060000; 22 | A0 = EMU_ReadU32(A0 - 5528); //+ 0xFFFFEA68 23 | V0 = A1 & 0x3F; 24 | V1 = EMU_ReadU16(A0 + 426); //+ 0x1AA 25 | V0 <<= 8; 26 | V1 &= 0xC0FF; 27 | V1 |= V0; 28 | V0 = A1; 29 | ZZ_JUMPREGISTER_BEGIN(RA); 30 | EMU_Write16(A0 + 426,V1); //+ 0x1AA 31 | ZZ_CLOCKCYCLES_JR(10); 32 | ZZ_JUMPREGISTER(0x80058BB8,ZZ_58900_2B8); 33 | ZZ_JUMPREGISTER_END(); 34 | #endif 35 | ZZ_MARK_TARGET(0x80058DDC,0x80058DFC,ZZ_58DDC); 36 | ZZ_MARK_TARGET(0x80058DFC,0x80058E24,ZZ_58DDC_20); 37 | -------------------------------------------------------------------------------- /srczz/zz_1f220.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_1F220: 3 | A0 = 0x80070000; 4 | A0 = EMU_ReadU32(A0 - 12884); //+ 0xFFFFCDAC 5 | SP -= 24; 6 | EMU_Write32(SP + 16,RA); //+ 0x10 7 | RA = 0x8001F238; //ZZ_1F220_18 8 | ZZ_CLOCKCYCLES(6,0x800116C0); 9 | goto ZZ_116C0; 10 | ZZ_1F220_18: 11 | A0 = 0x80070000; 12 | A0 = EMU_ReadU32(A0 - 12888); //+ 0xFFFFCDA8 13 | AT = 0x80060000; 14 | EMU_Write32(AT - 2524,R0); //+ 0xFFFFF624 15 | RA = 0x8001F250; //ZZ_1F220_30 16 | ZZ_CLOCKCYCLES(6,0x800116C0); 17 | goto ZZ_116C0; 18 | ZZ_1F220_30: 19 | RA = EMU_ReadU32(SP + 16); //+ 0x10 20 | SP += 24; 21 | ZZ_JUMPREGISTER_BEGIN(RA); 22 | ZZ_CLOCKCYCLES_JR(4); 23 | ZZ_JUMPREGISTER(0x800153E0,ZZ_15340_A0); 24 | ZZ_JUMPREGISTER_END(); 25 | #endif 26 | ZZ_MARK_TARGET(0x8001F220,0x8001F238,ZZ_1F220); 27 | ZZ_MARK_TARGET(0x8001F238,0x8001F250,ZZ_1F220_18); 28 | ZZ_MARK_TARGET(0x8001F250,0x8001F260,ZZ_1F220_30); 29 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Comparison/SLTIUInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class SLTIUInstruction : Instruction 6 | { 7 | private Register rs; 8 | private Register rd; 9 | private int imm; 10 | 11 | public SLTIUInstruction(Register rs,Register rd,int imm) 12 | { 13 | this.rs = rs; 14 | this.rd = rd; 15 | this.imm = imm; 16 | } 17 | 18 | public override string ToString() 19 | { 20 | return string.Format("SLTIU ${0},${1},{2}",rd,rs,imm); 21 | } 22 | 23 | public override void Discompile(Program p,int address,bool direct) 24 | { 25 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 26 | p.WriteLine("{0} = {1} < {2};",rd,rs,imm); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Comparison/SLTUInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class SLTUInstruction : Instruction 6 | { 7 | private Register rs; 8 | private Register rt; 9 | private Register rd; 10 | 11 | public SLTUInstruction(Register rs,Register rt,Register rd) 12 | { 13 | this.rs = rs; 14 | this.rt = rt; 15 | this.rd = rd; 16 | } 17 | 18 | public override string ToString() 19 | { 20 | return string.Format("SLTU ${0},${1},${2}",rd,rs,rt); 21 | } 22 | 23 | public override void Discompile(Program p,int address,bool direct) 24 | { 25 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 26 | p.WriteLine("{0} = {1} < {2};",rd,rs,rt); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /srczz/zz_35f84.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_35F84: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,S0); //+ 0x10 5 | S0 = -1; 6 | EMU_Write32(SP + 20,RA); //+ 0x14 7 | ZZ_CLOCKCYCLES(4,0x80035F94); 8 | ZZ_35F84_10: 9 | RA = 0x80035F9C; //ZZ_35F84_18 10 | ZZ_CLOCKCYCLES(2,0x80035EFC); 11 | goto ZZ_35EFC; 12 | ZZ_35F84_18: 13 | if (V0 == S0) 14 | { 15 | ZZ_CLOCKCYCLES(2,0x80035F94); 16 | goto ZZ_35F84_10; 17 | } 18 | RA = EMU_ReadU32(SP + 20); //+ 0x14 19 | S0 = EMU_ReadU32(SP + 16); //+ 0x10 20 | SP += 24; 21 | ZZ_JUMPREGISTER_BEGIN(RA); 22 | ZZ_CLOCKCYCLES_JR(7); 23 | ZZ_JUMPREGISTER(0x800369B0,ZZ_3696C_44); 24 | ZZ_JUMPREGISTER(0x8003679C,ZZ_36758_44); 25 | ZZ_JUMPREGISTER(0x80034AE4,ZZ_34A0C_D8); 26 | ZZ_JUMPREGISTER_END(); 27 | #endif 28 | ZZ_MARK_TARGET(0x80035F84,0x80035F94,ZZ_35F84); 29 | ZZ_MARK_TARGET(0x80035F94,0x80035F9C,ZZ_35F84_10); 30 | ZZ_MARK_TARGET(0x80035F9C,0x80035FB8,ZZ_35F84_18); 31 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Bitshift/SRAVInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class SRAVInstruction : Instruction 6 | { 7 | private Register rs; 8 | private Register rt; 9 | private Register rd; 10 | 11 | public SRAVInstruction(Register rs,Register rt,Register rd) 12 | { 13 | this.rs = rs; 14 | this.rt = rt; 15 | this.rd = rd; 16 | } 17 | 18 | public override string ToString() 19 | { 20 | return string.Format("SRAV ${0},${1},${2}",rd,rt,rs); 21 | } 22 | 23 | public override void Discompile(Program p,int address,bool direct) 24 | { 25 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 26 | p.WriteLine("{0} = (int32_t){1} >> {2};",rd,rt,rs); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Comparison/SLTIInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class SLTIInstruction : Instruction 6 | { 7 | private Register rs; 8 | private Register rd; 9 | private int imm; 10 | 11 | public SLTIInstruction(Register rs,Register rd,int imm) 12 | { 13 | this.rs = rs; 14 | this.rd = rd; 15 | this.imm = imm; 16 | } 17 | 18 | public override string ToString() 19 | { 20 | return string.Format("SLTI ${0},${1},{2}",rd,rs,imm); 21 | } 22 | 23 | public override void Discompile(Program p,int address,bool direct) 24 | { 25 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 26 | p.WriteLine("{0} = (int32_t){1} < {2};",rd,rs,imm); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /srczz/zz_4a41c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A41C: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | RA = 0x8004A42C; //ZZ_4A41C_10 6 | ZZ_CLOCKCYCLES(4,0x80049FB4); 7 | goto ZZ_49FB4; 8 | ZZ_4A41C_10: 9 | A1 = 0x80060000; 10 | A1 += 276; 11 | RA = 0x8004A43C; //ZZ_4A41C_20 12 | A0 = 1; 13 | ZZ_CLOCKCYCLES(4,0x8004A54C); 14 | goto ZZ_4A54C; 15 | ZZ_4A41C_20: 16 | RA = 0x8004A444; //ZZ_4A41C_28 17 | ZZ_CLOCKCYCLES(2,0x80049FC4); 18 | goto ZZ_49FC4; 19 | ZZ_4A41C_28: 20 | RA = EMU_ReadU32(SP + 16); //+ 0x10 21 | V0 = 1; 22 | ZZ_JUMPREGISTER_BEGIN(RA); 23 | SP += 24; 24 | ZZ_CLOCKCYCLES_JR(4); 25 | ZZ_JUMPREGISTER(0x8004A384,ZZ_4A364_20); 26 | ZZ_JUMPREGISTER_END(); 27 | #endif 28 | ZZ_MARK_TARGET(0x8004A41C,0x8004A42C,ZZ_4A41C); 29 | ZZ_MARK_TARGET(0x8004A42C,0x8004A43C,ZZ_4A41C_10); 30 | ZZ_MARK_TARGET(0x8004A43C,0x8004A444,ZZ_4A41C_20); 31 | ZZ_MARK_TARGET(0x8004A444,0x8004A454,ZZ_4A41C_28); 32 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Arithmetic/ADDIInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class ADDIInstruction : Instruction 6 | { 7 | private Register rs; 8 | private Register rd; 9 | private int imm; 10 | 11 | public ADDIInstruction(Register rs,Register rd,int imm) 12 | { 13 | this.rs = rs; 14 | this.rd = rd; 15 | this.imm = imm; 16 | } 17 | 18 | public override string ToString() 19 | { 20 | return string.Format("ADDI ${0},${1},{2}",rd,rs,imm); 21 | } 22 | 23 | public override void Discompile(Program p,int address,bool direct) 24 | { 25 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 26 | p.WriteLine("{0} = EMU_CheckedAdd({1},{2});",rd,rs,imm); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Arithmetic/ADDInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class ADDInstruction : Instruction 6 | { 7 | private Register rs; 8 | private Register rt; 9 | private Register rd; 10 | 11 | public ADDInstruction(Register rs,Register rt,Register rd) 12 | { 13 | this.rs = rs; 14 | this.rt = rt; 15 | this.rd = rd; 16 | } 17 | 18 | public override string ToString() 19 | { 20 | return string.Format("ADD ${0},${1},${2}",rd,rs,rt); 21 | } 22 | 23 | public override void Discompile(Program p,int address,bool direct) 24 | { 25 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 26 | p.WriteLine("{0} = EMU_CheckedAdd({1},{2});",rd,rs,rt); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Bitshift/SRAInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class SRAInstruction : Instruction 6 | { 7 | private Register rt; 8 | private Register rd; 9 | private int shamt; 10 | 11 | public SRAInstruction(Register rt,Register rd,int shamt) 12 | { 13 | this.rt = rt; 14 | this.rd = rd; 15 | this.shamt = shamt; 16 | } 17 | 18 | public override string ToString() 19 | { 20 | return string.Format("SRA ${0},${1},{2}",rd,rt,shamt); 21 | } 22 | 23 | public override void Discompile(Program p,int address,bool direct) 24 | { 25 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 26 | p.WriteLine("{0} = (int32_t){1} >> {2};",rd,rt,shamt); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /srczz/zz_36d24.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_36D24: 3 | SP -= 8; 4 | A2 = 0x12340000; 5 | A2 |= 0x5678; 6 | if (!A1) 7 | { 8 | V1 = A1 - 1; 9 | ZZ_CLOCKCYCLES(5,0x80036D50); 10 | goto ZZ_36D24_2C; 11 | } 12 | V1 = A1 - 1; 13 | A1 = -1; 14 | ZZ_CLOCKCYCLES(6,0x80036D3C); 15 | ZZ_36D24_18: 16 | V0 = EMU_ReadU32(A0); 17 | A0 += 4; 18 | V1 -= 1; 19 | if (V1 != A1) 20 | { 21 | A2 += V0; 22 | ZZ_CLOCKCYCLES(5,0x80036D3C); 23 | goto ZZ_36D24_18; 24 | } 25 | A2 += V0; 26 | ZZ_CLOCKCYCLES(5,0x80036D50); 27 | ZZ_36D24_2C: 28 | V0 = A2; 29 | SP += 8; 30 | ZZ_JUMPREGISTER_BEGIN(RA); 31 | ZZ_CLOCKCYCLES_JR(4); 32 | ZZ_JUMPREGISTER(0x80036C58,ZZ_36C10_48); 33 | ZZ_JUMPREGISTER(0x80036CD0,ZZ_36C8C_44); 34 | ZZ_JUMPREGISTER_END(); 35 | #endif 36 | ZZ_MARK_TARGET(0x80036D24,0x80036D3C,ZZ_36D24); 37 | ZZ_MARK_TARGET(0x80036D3C,0x80036D50,ZZ_36D24_18); 38 | ZZ_MARK_TARGET(0x80036D50,0x80036D60,ZZ_36D24_2C); 39 | -------------------------------------------------------------------------------- /srczz/zz_4a364.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A364: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | RA = 0x8004A374; //ZZ_4A364_10 6 | ZZ_CLOCKCYCLES(4,0x8004A570); 7 | goto ZZ_4A570; 8 | ZZ_4A364_10: 9 | RA = 0x8004A37C; //ZZ_4A364_18 10 | ZZ_CLOCKCYCLES(2,0x8004A51C); 11 | goto ZZ_4A51C; 12 | ZZ_4A364_18: 13 | RA = 0x8004A384; //ZZ_4A364_20 14 | ZZ_CLOCKCYCLES(2,0x8004A41C); 15 | goto ZZ_4A41C; 16 | ZZ_4A364_20: 17 | AT = 0x80060000; 18 | EMU_Write32(AT - 12808,R0); //+ 0xFFFFCDF8 19 | RA = EMU_ReadU32(SP + 16); //+ 0x10 20 | SP += 24; 21 | ZZ_JUMPREGISTER_BEGIN(RA); 22 | ZZ_CLOCKCYCLES_JR(6); 23 | ZZ_JUMPREGISTER(0x80015900,ZZ_158C4_3C); 24 | ZZ_JUMPREGISTER_END(); 25 | #endif 26 | ZZ_MARK_TARGET(0x8004A364,0x8004A374,ZZ_4A364); 27 | ZZ_MARK_TARGET(0x8004A374,0x8004A37C,ZZ_4A364_10); 28 | ZZ_MARK_TARGET(0x8004A37C,0x8004A384,ZZ_4A364_18); 29 | ZZ_MARK_TARGET(0x8004A384,0x8004A39C,ZZ_4A364_20); 30 | -------------------------------------------------------------------------------- /srczz/zz_57a6c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_57A6C: 3 | V0 = 1; 4 | if (A0 != V0) 5 | { 6 | ZZ_CLOCKCYCLES(3,0x80057A84); 7 | goto ZZ_57A6C_18; 8 | } 9 | AT = 0x80060000; 10 | EMU_Write32(AT - 5476,R0); //+ 0xFFFFEA9C 11 | ZZ_CLOCKCYCLES(6,0x80057A8C); 12 | goto ZZ_57A6C_20; 13 | ZZ_57A6C_18: 14 | AT = 0x80060000; 15 | EMU_Write32(AT - 5476,V0); //+ 0xFFFFEA9C 16 | ZZ_CLOCKCYCLES(2,0x80057A8C); 17 | ZZ_57A6C_20: 18 | ZZ_JUMPREGISTER_BEGIN(RA); 19 | ZZ_CLOCKCYCLES_JR(2); 20 | ZZ_JUMPREGISTER(0x80057768,ZZ_5774C_1C); 21 | ZZ_JUMPREGISTER(0x8005AAD4,ZZ_5AA94_40); 22 | ZZ_JUMPREGISTER(0x8005ABE8,ZZ_5AB94_54); 23 | ZZ_JUMPREGISTER(0x8005ACAC,ZZ_5AB94_118); 24 | ZZ_JUMPREGISTER(0x8005AE70,ZZ_5AB94_2DC); 25 | ZZ_JUMPREGISTER_END(); 26 | #endif 27 | ZZ_MARK_TARGET(0x80057A6C,0x80057A84,ZZ_57A6C); 28 | ZZ_MARK_TARGET(0x80057A84,0x80057A8C,ZZ_57A6C_18); 29 | ZZ_MARK_TARGET(0x80057A8C,0x80057A94,ZZ_57A6C_20); 30 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Arithmetic/SUBInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class SUBInstruction : Instruction 6 | { 7 | private Register rs; 8 | private Register rt; 9 | private Register rd; 10 | 11 | public SUBInstruction(Register rs,Register rt,Register rd) 12 | { 13 | this.rs = rs; 14 | this.rt = rt; 15 | this.rd = rd; 16 | } 17 | 18 | public override string ToString() 19 | { 20 | return string.Format("SUB ${0},${1},${2}",rd,rs,rt); 21 | } 22 | 23 | public override void Discompile(Program p,int address,bool direct) 24 | { 25 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 26 | p.WriteLine("{0} = EMU_CheckedSubtract({1},{2});",rd,rs,rt); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Comparison/SLTInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class SLTInstruction : Instruction 6 | { 7 | private Register rs; 8 | private Register rt; 9 | private Register rd; 10 | 11 | public SLTInstruction(Register rs,Register rt,Register rd) 12 | { 13 | this.rs = rs; 14 | this.rt = rt; 15 | this.rd = rd; 16 | } 17 | 18 | public override string ToString() 19 | { 20 | return string.Format("SLT ${0},${1},${2}",rd,rs,rt); 21 | } 22 | 23 | public override void Discompile(Program p,int address,bool direct) 24 | { 25 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 26 | p.WriteLine("{0} = (int32_t){1} < (int32_t){2};",rd,rs,rt); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /srczz/zz_3a20c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_3A20C: 3 | V0 = A0 - 31; 4 | if (V0) 5 | { 6 | ZZ_CLOCKCYCLES(3,0x8003A224); 7 | goto ZZ_3A20C_18; 8 | } 9 | S6 -= 4; 10 | ZZ_JUMPREGISTER_BEGIN(RA); 11 | V0 = S6; 12 | ZZ_CLOCKCYCLES_JR(6); 13 | ZZ_JUMPREGISTER(0x8003AF58,ZZ_3AC50_308); 14 | ZZ_JUMPREGISTER(0x8003AF88,ZZ_3AC50_338); 15 | ZZ_JUMPREGISTER(0x8003AFB8,ZZ_3AC50_368); 16 | ZZ_JUMPREGISTER(0x8003AFE0,ZZ_3AC50_390); 17 | ZZ_JUMPREGISTER_END(); 18 | ZZ_3A20C_18: 19 | A0 <<= 2; 20 | A0 += 64; 21 | ZZ_JUMPREGISTER_BEGIN(RA); 22 | V0 = S0 + A0; 23 | ZZ_CLOCKCYCLES_JR(4); 24 | ZZ_JUMPREGISTER(0x8003AF58,ZZ_3AC50_308); 25 | ZZ_JUMPREGISTER(0x8003AF88,ZZ_3AC50_338); 26 | ZZ_JUMPREGISTER(0x8003AFB8,ZZ_3AC50_368); 27 | ZZ_JUMPREGISTER(0x8003AFE0,ZZ_3AC50_390); 28 | ZZ_JUMPREGISTER_END(); 29 | #endif 30 | ZZ_MARK_TARGET(0x8003A20C,0x8003A224,ZZ_3A20C); 31 | ZZ_MARK_TARGET(0x8003A224,0x8003A234,ZZ_3A20C_18); 32 | -------------------------------------------------------------------------------- /srczz/zz_3c140.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_3C140: 3 | if ((int32_t)A0 >= 0) 4 | { 5 | ZZ_CLOCKCYCLES(2,0x8003C14C); 6 | goto ZZ_3C140_C; 7 | } 8 | A0 = -A0; 9 | ZZ_CLOCKCYCLES(3,0x8003C14C); 10 | ZZ_3C140_C: 11 | if ((int32_t)A1 >= 0) 12 | { 13 | ZZ_CLOCKCYCLES(2,0x8003C158); 14 | goto ZZ_3C140_18; 15 | } 16 | A1 = -A1; 17 | ZZ_CLOCKCYCLES(3,0x8003C158); 18 | ZZ_3C140_18: 19 | EMU_SMultiply(A0,A0); 20 | A2 = LO; 21 | A3 = HI; 22 | EMU_SMultiply(A1,A1); 23 | T0 = LO; 24 | T1 = HI; 25 | V0 = A2 + T0; 26 | V1 = V0 < A2; 27 | V1 += A3; 28 | V1 += T1; 29 | V0 >>= 13; 30 | V1 <<= 19; 31 | ZZ_JUMPREGISTER_BEGIN(RA); 32 | V0 |= V1; 33 | ZZ_CLOCKCYCLES_JR(16); 34 | ZZ_JUMPREGISTER(0x800329B4,ZZ_32958_5C); 35 | ZZ_JUMPREGISTER_END(); 36 | #endif 37 | ZZ_MARK_TARGET(0x8003C140,0x8003C14C,ZZ_3C140); 38 | ZZ_MARK_TARGET(0x8003C14C,0x8003C158,ZZ_3C140_C); 39 | ZZ_MARK_TARGET(0x8003C158,0x8003C198,ZZ_3C140_18); 40 | -------------------------------------------------------------------------------- /srczz/zz_5a660.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_5A660: 3 | V1 = A0 & 0xFF; 4 | V0 = V1 < 25; 5 | if (!V0) 6 | { 7 | ZZ_CLOCKCYCLES(4,0x8005A678); 8 | goto ZZ_5A660_18; 9 | } 10 | if (V1) 11 | { 12 | V0 = V1; 13 | ZZ_CLOCKCYCLES(6,0x8005A680); 14 | goto ZZ_5A660_20; 15 | } 16 | V0 = V1; 17 | ZZ_CLOCKCYCLES(6,0x8005A678); 18 | ZZ_5A660_18: 19 | V0 = 255; 20 | ZZ_CLOCKCYCLES(2,0x8005A688); 21 | goto ZZ_5A660_28; 22 | ZZ_5A660_20: 23 | AT = 0x80070000; 24 | EMU_Write8(AT - 32136,A0); //+ 0xFFFF8278 25 | ZZ_CLOCKCYCLES(2,0x8005A688); 26 | ZZ_5A660_28: 27 | ZZ_JUMPREGISTER_BEGIN(RA); 28 | ZZ_CLOCKCYCLES_JR(2); 29 | ZZ_JUMPREGISTER(0x800340E4,ZZ_34034_B0); 30 | ZZ_JUMPREGISTER_END(); 31 | #endif 32 | ZZ_MARK_TARGET(0x8005A660,0x8005A678,ZZ_5A660); 33 | ZZ_MARK_TARGET(0x8005A678,0x8005A680,ZZ_5A660_18); 34 | ZZ_MARK_TARGET(0x8005A680,0x8005A688,ZZ_5A660_20); 35 | ZZ_MARK_TARGET(0x8005A688,0x8005A690,ZZ_5A660_28); 36 | -------------------------------------------------------------------------------- /srczz/zz_4b1a8.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4B1A8: 3 | SP -= 24; 4 | A0 = 0x80060000; 5 | A0 -= 8388; 6 | EMU_Write32(SP + 16,RA); //+ 0x10 7 | RA = 0x8004B1C0; //ZZ_4B1A8_18 8 | A1 = 8; 9 | ZZ_CLOCKCYCLES(6,0x8004B424); 10 | goto ZZ_4B424; 11 | ZZ_4B1A8_18: 12 | A0 = 3; 13 | V0 = 0x80060000; 14 | V0 = EMU_ReadU32(V0 - 8392); //+ 0xFFFFDF38 15 | A1 = 0x80050000; 16 | A1 -= 19976; 17 | EMU_Write32(V0,R0); 18 | RA = 0x8004B1E0; //ZZ_4B1A8_38 19 | ZZ_CLOCKCYCLES(8,0x8004A940); 20 | goto ZZ_4A940; 21 | ZZ_4B1A8_38: 22 | V0 = 0x80050000; 23 | V0 -= 19588; 24 | RA = EMU_ReadU32(SP + 16); //+ 0x10 25 | SP += 24; 26 | ZZ_JUMPREGISTER_BEGIN(RA); 27 | ZZ_CLOCKCYCLES_JR(6); 28 | ZZ_JUMPREGISTER(0x8004AB54,ZZ_4AAA8_AC); 29 | ZZ_JUMPREGISTER_END(); 30 | #endif 31 | ZZ_MARK_TARGET(0x8004B1A8,0x8004B1C0,ZZ_4B1A8); 32 | ZZ_MARK_TARGET(0x8004B1C0,0x8004B1E0,ZZ_4B1A8_18); 33 | ZZ_MARK_TARGET(0x8004B1E0,0x8004B1F8,ZZ_4B1A8_38); 34 | -------------------------------------------------------------------------------- /src/dma.c: -------------------------------------------------------------------------------- 1 | #include "dma.h" 2 | #include "pcsx.h" 3 | 4 | void DMA_SetAddress(int channel,uint32_t value) 5 | { 6 | PCSX_Write32(0x1F801080 + channel * 0x10,value); 7 | } 8 | 9 | void DMA_SetBlockData(int channel,uint32_t value) 10 | { 11 | PCSX_Write32(0x1F801084 + channel * 0x10,value); 12 | } 13 | 14 | uint32_t DMA_GetMode(int channel) 15 | { 16 | return PCSX_Read32(0x1F801088 + channel * 0x10); 17 | } 18 | 19 | void DMA_SetMode(int channel,uint32_t value) 20 | { 21 | PCSX_Write32(0x1F801088 + channel * 0x10,value); 22 | } 23 | 24 | uint32_t DMA_GetControlRegister(void) 25 | { 26 | return PCSX_Read32(0x1F8010F0); 27 | } 28 | 29 | void DMA_SetControlRegister(uint32_t value) 30 | { 31 | PCSX_Write32(0x1F8010F0,value); 32 | } 33 | 34 | uint32_t DMA_GetInterruptRegister(void) 35 | { 36 | return PCSX_Read32(0x1F8010F4); 37 | } 38 | 39 | void DMA_SetInterruptRegister(uint32_t value) 40 | { 41 | PCSX_Write32(0x1F8010F4,value); 42 | } 43 | -------------------------------------------------------------------------------- /srczz/zz_11e24.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_11E24: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU32(V0 - 3052); //+ 0xFFFFF414 5 | if (V0) 6 | { 7 | ZZ_CLOCKCYCLES(5,0x80011E78); 8 | goto ZZ_11E24_54; 9 | } 10 | V0 = 0x80040000; 11 | V0 += 9912; 12 | AT = 0x80060000; 13 | EMU_Write32(AT + 11460,V0); //+ 0x2CC4 14 | V0 = 0x80040000; 15 | V0 += 10552; 16 | AT = 0x80060000; 17 | EMU_Write32(AT + 11464,V0); //+ 0x2CC8 18 | V0 = 0x80040000; 19 | V0 += 10208; 20 | AT = 0x80060000; 21 | EMU_Write32(AT + 11468,V0); //+ 0x2CCC 22 | V0 = 0x80040000; 23 | V0 += 10928; 24 | AT = 0x80060000; 25 | EMU_Write32(AT + 11472,V0); //+ 0x2CD0 26 | ZZ_CLOCKCYCLES(21,0x80011E78); 27 | ZZ_11E24_54: 28 | ZZ_JUMPREGISTER_BEGIN(RA); 29 | ZZ_CLOCKCYCLES_JR(2); 30 | ZZ_JUMPREGISTER(0x80020DC0,ZZ_20C80_140); 31 | ZZ_JUMPREGISTER_END(); 32 | #endif 33 | ZZ_MARK_TARGET(0x80011E24,0x80011E78,ZZ_11E24); 34 | ZZ_MARK_TARGET(0x80011E78,0x80011E80,ZZ_11E24_54); 35 | -------------------------------------------------------------------------------- /srczz/zz_233c8.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_233C8: 3 | V1 = 0x80040000; 4 | V1 = EMU_ReadU32(V1 - 16068); //+ 0xFFFFC13C 5 | V0 = 0x1; 6 | AT = 0x80060000; 7 | EMU_Write32(AT - 17316,V0); //+ 0xFFFFBC5C 8 | V0 = 0x155; 9 | AT = 0x80060000; 10 | EMU_Write32(AT - 17308,V0); //+ 0xFFFFBC64 11 | AT = 0x80060000; 12 | EMU_Write32(AT - 17312,V1); //+ 0xFFFFBC60 13 | A1 = 0x80060000; 14 | A1 += 2992; 15 | A0 = 0x80060000; 16 | A0 -= 17304; 17 | V0 = EMU_ReadU32(A1); 18 | V1 = EMU_ReadU32(A1 + 4); //+ 0x4 19 | EMU_Write32(A0,V0); 20 | EMU_Write32(A0 + 4,V1); //+ 0x4 21 | V0 = EMU_ReadU32(A1 + 8); //+ 0x8 22 | EMU_Write32(A0 + 8,V0); //+ 0x8 23 | ZZ_JUMPREGISTER_BEGIN(RA); 24 | ZZ_CLOCKCYCLES_JR(23); 25 | ZZ_JUMPREGISTER(0x8002644C,ZZ_26368_E4); 26 | ZZ_JUMPREGISTER(0x80026784,ZZ_26700_84); 27 | ZZ_JUMPREGISTER(0x80022470,ZZ_22438_38); 28 | ZZ_JUMPREGISTER_END(); 29 | #endif 30 | ZZ_MARK_TARGET(0x800233C8,0x80023424,ZZ_233C8); 31 | -------------------------------------------------------------------------------- /srczz/zz_43328.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_43328: 3 | V0 = 192; 4 | T8 = (int32_t)T1 >> 16; 5 | EMU_SMultiply(V0,T8); 6 | T9 = (int32_t)T2 >> 16; 7 | A1 = (int32_t)T3 >> 16; 8 | A2 = T3 << 16; 9 | T4 = EMU_CheckedSubtract(R0,T4); 10 | T8 = LO; 11 | A0 = T2 << 16; 12 | A0 = (int32_t)A0 >> 16; 13 | EMU_SMultiply(V0,T9); 14 | T1 &= 0xFFFF; 15 | T8 = (int32_t)T8 >> 8; 16 | T8 = EMU_CheckedSubtract(R0,T8); 17 | A1 = EMU_CheckedSubtract(R0,A1); 18 | A2 = EMU_CheckedSubtract(R0,A2); 19 | T9 = LO; 20 | T8 <<= 16; 21 | T1 |= T8; 22 | EMU_SMultiply(V0,A0); 23 | T9 = (int32_t)T9 >> 8; 24 | T9 = EMU_CheckedSubtract(R0,T9); 25 | T9 <<= 16; 26 | A1 <<= 16; 27 | A2 >>= 16; 28 | T3 = A2 | A1; 29 | A0 = LO; 30 | A0 = (int32_t)A0 >> 8; 31 | A0 = EMU_CheckedSubtract(R0,A0); 32 | A0 &= 0xFFFF; 33 | T2 = A0 | T9; 34 | ZZ_CLOCKCYCLES(32,0x80043310); 35 | goto ZZ_4330C_4; 36 | #endif 37 | ZZ_MARK_TARGET(0x80043328,0x800433A8,ZZ_43328); 38 | -------------------------------------------------------------------------------- /srczz/zz_31514.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_31514: 3 | SP -= 40; 4 | EMU_Write32(SP + 32,RA); //+ 0x20 5 | V0 = EMU_ReadU32(A0); 6 | V1 = EMU_ReadU32(A1); 7 | V0 = V0 - V1; 8 | V0 = (int32_t)V0 >> 8; 9 | EMU_SMultiply(V0,V0); 10 | EMU_Write32(SP + 16,V0); //+ 0x10 11 | V0 = EMU_ReadU32(A0 + 8); //+ 0x8 12 | V1 = EMU_ReadU32(A1 + 8); //+ 0x8 13 | A2 = LO; 14 | V0 = V0 - V1; 15 | V0 = (int32_t)V0 >> 8; 16 | EMU_SMultiply(V0,V0); 17 | EMU_Write32(SP + 24,V0); //+ 0x18 18 | V1 = LO; 19 | RA = 0x80031560; //ZZ_31514_4C 20 | A0 = A2 + V1; 21 | ZZ_CLOCKCYCLES(19,0x80041D10); 22 | goto ZZ_41D10; 23 | ZZ_31514_4C: 24 | RA = EMU_ReadU32(SP + 32); //+ 0x20 25 | V0 <<= 8; 26 | ZZ_JUMPREGISTER_BEGIN(RA); 27 | SP += 40; 28 | ZZ_CLOCKCYCLES_JR(4); 29 | ZZ_JUMPREGISTER(0x80038024,ZZ_37930_6F4); 30 | ZZ_JUMPREGISTER_END(); 31 | #endif 32 | ZZ_MARK_TARGET(0x80031514,0x80031560,ZZ_31514); 33 | ZZ_MARK_TARGET(0x80031560,0x80031570,ZZ_31514_4C); 34 | -------------------------------------------------------------------------------- /srczz/zz_22438.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_22438: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadS8(V0 - 17357); //+ 0xFFFFBC33 5 | SP -= 24; 6 | EMU_Write32(SP + 16,RA); //+ 0x10 7 | AT = 0x80060000; 8 | EMU_Write32(AT + 2960,R0); //+ 0xB90 9 | if (!V0) 10 | { 11 | ZZ_CLOCKCYCLES(8,0x80022468); 12 | goto ZZ_22438_30; 13 | } 14 | AT = 0x80060000; 15 | EMU_Write32(AT - 17316,R0); //+ 0xFFFFBC5C 16 | ZZ_CLOCKCYCLES(12,0x80022470); 17 | goto ZZ_22438_38; 18 | ZZ_22438_30: 19 | RA = 0x80022470; //ZZ_22438_38 20 | ZZ_CLOCKCYCLES(2,0x800233C8); 21 | goto ZZ_233C8; 22 | ZZ_22438_38: 23 | RA = EMU_ReadU32(SP + 16); //+ 0x10 24 | SP += 24; 25 | ZZ_JUMPREGISTER_BEGIN(RA); 26 | ZZ_CLOCKCYCLES_JR(4); 27 | ZZ_JUMPREGISTER(0x80020978,ZZ_20304_674); 28 | ZZ_JUMPREGISTER_END(); 29 | #endif 30 | ZZ_MARK_TARGET(0x80022438,0x80022468,ZZ_22438); 31 | ZZ_MARK_TARGET(0x80022468,0x80022470,ZZ_22438_30); 32 | ZZ_MARK_TARGET(0x80022470,0x80022480,ZZ_22438_38); 33 | -------------------------------------------------------------------------------- /srczz/zz_2ff84.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_2FF84: 3 | SP -= 32; 4 | EMU_Write32(SP + 16,S0); //+ 0x10 5 | S0 = A1; 6 | EMU_Write32(SP + 20,S1); //+ 0x14 7 | S1 = A2; 8 | A1 = 0x1; 9 | EMU_Write32(SP + 24,RA); //+ 0x18 10 | RA = 0x8002FFA8; //ZZ_2FF84_24 11 | A2 = R0; 12 | ZZ_CLOCKCYCLES(9,0x80014364); 13 | goto ZZ_14364; 14 | ZZ_2FF84_24: 15 | S0 <<= 1; 16 | S0 += S1; 17 | S0 <<= 2; 18 | V0 += S0; 19 | V0 = EMU_ReadU32(V0 + 20); //+ 0x14 20 | V0 += 3; 21 | RA = EMU_ReadU32(SP + 24); //+ 0x18 22 | S1 = EMU_ReadU32(SP + 20); //+ 0x14 23 | S0 = EMU_ReadU32(SP + 16); //+ 0x10 24 | SP += 32; 25 | ZZ_JUMPREGISTER_BEGIN(RA); 26 | ZZ_CLOCKCYCLES_JR(13); 27 | ZZ_JUMPREGISTER(0x800219F0,ZZ_20C80_D70); 28 | ZZ_JUMPREGISTER(0x80021A14,ZZ_20C80_D94); 29 | ZZ_JUMPREGISTER(0x80021A30,ZZ_20C80_DB0); 30 | ZZ_JUMPREGISTER_END(); 31 | #endif 32 | ZZ_MARK_TARGET(0x8002FF84,0x8002FFA8,ZZ_2FF84); 33 | ZZ_MARK_TARGET(0x8002FFA8,0x8002FFDC,ZZ_2FF84_24); 34 | -------------------------------------------------------------------------------- /srczz/zz_4a910.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A910: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU32(V0 - 8452); //+ 0xFFFFDEFC 5 | SP -= 24; 6 | EMU_Write32(SP + 16,RA); //+ 0x10 7 | V0 = EMU_ReadU32(V0 + 12); //+ 0xC 8 | ZZ_JUMPREGISTER_BEGIN(V0); 9 | RA = 0x8004A930; //ZZ_4A910_20 10 | ZZ_CLOCKCYCLES_JR(8); 11 | // UNIMPLEMENTED JUMP-TO-REGISTER-AND-LINK (V0,8004A928) 12 | ZZ_JUMPREGISTER_END(); 13 | ZZ_4A910_20: 14 | RA = EMU_ReadU32(SP + 16); //+ 0x10 15 | SP += 24; 16 | ZZ_JUMPREGISTER_BEGIN(RA); 17 | ZZ_CLOCKCYCLES_JR(4); 18 | ZZ_JUMPREGISTER(0x80052FD4,ZZ_52FC4_10); 19 | ZZ_JUMPREGISTER(0x800501B4,ZZ_501A0_14); 20 | ZZ_JUMPREGISTER(0x80015788,ZZ_15738_50); 21 | ZZ_JUMPREGISTER(0x8004BEAC,ZZ_4BE1C_90); 22 | ZZ_JUMPREGISTER(0x80048534,ZZ_48504_30); 23 | ZZ_JUMPREGISTER(0x800485BC,ZZ_48554_68); 24 | ZZ_JUMPREGISTER_END(); 25 | #endif 26 | ZZ_MARK_TARGET(0x8004A910,0x8004A930,ZZ_4A910); 27 | ZZ_MARK_TARGET(0x8004A930,0x8004A940,ZZ_4A910_20); 28 | -------------------------------------------------------------------------------- /srcemu/hookemu.sln: -------------------------------------------------------------------------------- 1 | 2 | Microsoft Visual Studio Solution File, Format Version 9.00 3 | # Visual Studio 2005 4 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "hookemu", "hookemu.vcproj", "{35F99351-5F37-4B6F-9BCA-89CA865ACE89}" 5 | EndProject 6 | Global 7 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 8 | Debug|Win32 = Debug|Win32 9 | Release|Win32 = Release|Win32 10 | EndGlobalSection 11 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 12 | {35F99351-5F37-4B6F-9BCA-89CA865ACE89}.Debug|Win32.ActiveCfg = Debug|Win32 13 | {35F99351-5F37-4B6F-9BCA-89CA865ACE89}.Debug|Win32.Build.0 = Debug|Win32 14 | {35F99351-5F37-4B6F-9BCA-89CA865ACE89}.Release|Win32.ActiveCfg = Release|Win32 15 | {35F99351-5F37-4B6F-9BCA-89CA865ACE89}.Release|Win32.Build.0 = Release|Win32 16 | EndGlobalSection 17 | GlobalSection(SolutionProperties) = preSolution 18 | HideSolutionNode = FALSE 19 | EndGlobalSection 20 | EndGlobal 21 | -------------------------------------------------------------------------------- /srczz/zz_20240.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_20240: 3 | V1 = EMU_ReadU32(A0 + 16); //+ 0x10 4 | V0 = EMU_ReadU32(V1 + 636); //+ 0x27C 5 | V0 &= 0x1; 6 | if (V0) 7 | { 8 | V0 = 0x10000; 9 | ZZ_CLOCKCYCLES(7,0x80020288); 10 | goto ZZ_20240_48; 11 | } 12 | V0 = 0x10000; 13 | V0 |= 0x9000; 14 | AT = 0x80070000; 15 | EMU_Write32(AT - 12152,R0); //+ 0xFFFFD088 16 | AT = 0x80070000; 17 | EMU_Write32(AT - 12144,R0); //+ 0xFFFFD090 18 | AT = 0x80070000; 19 | EMU_Write32(AT - 12148,V0); //+ 0xFFFFD08C 20 | V0 = EMU_ReadU32(V1 + 636); //+ 0x27C 21 | V0 |= 0x1; 22 | EMU_Write32(V1 + 636,V0); //+ 0x27C 23 | ZZ_CLOCKCYCLES(18,0x80020288); 24 | ZZ_20240_48: 25 | ZZ_JUMPREGISTER_BEGIN(RA); 26 | ZZ_CLOCKCYCLES_JR(2); 27 | ZZ_JUMPREGISTER(0x80020160,ZZ_20024_13C); 28 | ZZ_JUMPREGISTER(0x800208F8,ZZ_20304_5F4); 29 | ZZ_JUMPREGISTER_END(); 30 | #endif 31 | ZZ_MARK_TARGET(0x80020240,0x80020288,ZZ_20240); 32 | ZZ_MARK_TARGET(0x80020288,0x80020290,ZZ_20240_48); 33 | -------------------------------------------------------------------------------- /srczz/zz_363f0.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_363F0: 3 | V0 = EMU_ReadU32(GP + 232); //+ 0xE8 4 | V1 = EMU_ReadU32(V0 + 4); //+ 0x4 5 | A0 = ~A0; 6 | V1 &= A0; 7 | EMU_Write32(V0 + 4,V1); //+ 0x4 8 | ZZ_JUMPREGISTER_BEGIN(RA); 9 | V0 = R0; 10 | ZZ_CLOCKCYCLES_JR(8); 11 | ZZ_JUMPREGISTER(0x800366F4,ZZ_366AC_48); 12 | ZZ_JUMPREGISTER(0x80036690,ZZ_36668_28); 13 | ZZ_JUMPREGISTER(0x80036460,ZZ_36410_50); 14 | ZZ_JUMPREGISTER(0x800369F8,ZZ_369C4_34); 15 | ZZ_JUMPREGISTER(0x80034B70,ZZ_34B44_2C); 16 | ZZ_JUMPREGISTER(0x80034BA8,ZZ_34B44_64); 17 | ZZ_JUMPREGISTER(0x80035D70,ZZ_35D34_3C); 18 | ZZ_JUMPREGISTER(0x80034B2C,ZZ_34A0C_120); 19 | ZZ_JUMPREGISTER(0x80034AF4,ZZ_34A0C_E8); 20 | ZZ_JUMPREGISTER(0x80034F60,ZZ_34F00_60); 21 | ZZ_JUMPREGISTER(0x80034CB8,ZZ_34BCC_EC); 22 | ZZ_JUMPREGISTER(0x80035CF8,ZZ_3578C_56C); 23 | ZZ_JUMPREGISTER(0x80035D10,ZZ_3578C_584); 24 | ZZ_JUMPREGISTER_END(); 25 | #endif 26 | ZZ_MARK_TARGET(0x800363F0,0x80036410,ZZ_363F0); 27 | -------------------------------------------------------------------------------- /srczz/zz_12250.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_12250: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | V1 = EMU_ReadU32(A0); 6 | V0 = V1 & 0x3; 7 | if (!V0) 8 | { 9 | ZZ_CLOCKCYCLES(7,0x80012280); 10 | goto ZZ_12250_30; 11 | } 12 | A0 = EMU_ReadU32(A0 + 4); //+ 0x4 13 | RA = 0x80012278; //ZZ_12250_28 14 | ZZ_CLOCKCYCLES(10,0x80012010); 15 | goto ZZ_12010; 16 | ZZ_12250_28: 17 | ZZ_CLOCKCYCLES(2,0x80012284); 18 | goto ZZ_12250_34; 19 | ZZ_12250_30: 20 | V0 = EMU_ReadU32(V1 + 8); //+ 0x8 21 | ZZ_CLOCKCYCLES(1,0x80012284); 22 | ZZ_12250_34: 23 | RA = EMU_ReadU32(SP + 16); //+ 0x10 24 | SP += 24; 25 | ZZ_JUMPREGISTER_BEGIN(RA); 26 | ZZ_CLOCKCYCLES_JR(4); 27 | ZZ_JUMPREGISTER(0x800122DC,ZZ_12294_48); 28 | ZZ_JUMPREGISTER_END(); 29 | #endif 30 | ZZ_MARK_TARGET(0x80012250,0x80012278,ZZ_12250); 31 | ZZ_MARK_TARGET(0x80012278,0x80012280,ZZ_12250_28); 32 | ZZ_MARK_TARGET(0x80012280,0x80012284,ZZ_12250_30); 33 | ZZ_MARK_TARGET(0x80012284,0x80012294,ZZ_12250_34); 34 | -------------------------------------------------------------------------------- /srczz/zz_4fe9c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4FE9C: 3 | if (A2) 4 | { 5 | V0 = A0 << 1; 6 | ZZ_CLOCKCYCLES(2,0x8004FEBC); 7 | goto ZZ_4FE9C_20; 8 | } 9 | V0 = A0 << 1; 10 | V1 = 0x80060000; 11 | V1 = EMU_ReadU32(V1 - 5528); //+ 0xFFFFEA68 12 | V0 += V1; 13 | EMU_Write16(V0,A1); 14 | ZZ_CLOCKCYCLES(8,0x8004FED8); 15 | goto ZZ_4FE9C_3C; 16 | ZZ_4FE9C_20: 17 | A0 = 0x80060000; 18 | A0 = EMU_ReadU32(A0 - 5528); //+ 0xFFFFEA68 19 | V1 = 0x80060000; 20 | V1 = EMU_ReadU32(V1 - 5488); //+ 0xFFFFEA90 21 | V0 += A0; 22 | V1 = A1 >> V1; 23 | EMU_Write16(V0,V1); 24 | ZZ_CLOCKCYCLES(7,0x8004FED8); 25 | ZZ_4FE9C_3C: 26 | ZZ_JUMPREGISTER_BEGIN(RA); 27 | ZZ_CLOCKCYCLES_JR(2); 28 | ZZ_JUMPREGISTER(0x80050230,ZZ_501A0_90); 29 | ZZ_JUMPREGISTER(0x800508BC,ZZ_50440_47C); 30 | ZZ_JUMPREGISTER_END(); 31 | #endif 32 | ZZ_MARK_TARGET(0x8004FE9C,0x8004FEBC,ZZ_4FE9C); 33 | ZZ_MARK_TARGET(0x8004FEBC,0x8004FED8,ZZ_4FE9C_20); 34 | ZZ_MARK_TARGET(0x8004FED8,0x8004FEE0,ZZ_4FE9C_3C); 35 | -------------------------------------------------------------------------------- /srczz/zz_2cdcc.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_2CDCC: 3 | A0 = 0x1F800000; 4 | A0 |= 0x100; 5 | V1 = 0x1F800000; 6 | V1 |= 0x180; 7 | V0 = 0x1F800000; 8 | V0 |= 0x380; 9 | A3 = R0; 10 | A2 = 0x1F800000; 11 | A2 |= 0x380; 12 | A1 = 0x80060000; 13 | A1 -= 16720; 14 | EMU_Write32(GP + 584,A0); //+ 0x248 15 | EMU_Write32(GP + 508,V1); //+ 0x1FC 16 | EMU_Write32(GP + 620,V0); //+ 0x26C 17 | ZZ_CLOCKCYCLES(14,0x8002CE04); 18 | ZZ_2CDCC_38: 19 | V0 = EMU_ReadU32(A1); 20 | A1 += 4; 21 | A3 += 1; 22 | EMU_Write32(A2,V0); 23 | V0 = (int32_t)A3 < 32; 24 | if (V0) 25 | { 26 | A2 += 4; 27 | ZZ_CLOCKCYCLES(7,0x8002CE04); 28 | goto ZZ_2CDCC_38; 29 | } 30 | A2 += 4; 31 | ZZ_JUMPREGISTER_BEGIN(RA); 32 | V0 = -255; 33 | ZZ_CLOCKCYCLES_JR(9); 34 | ZZ_JUMPREGISTER(0x80014FC8,ZZ_14D6C_25C); 35 | ZZ_JUMPREGISTER(0x8001E150,ZZ_1D860_8F0); 36 | ZZ_JUMPREGISTER_END(); 37 | #endif 38 | ZZ_MARK_TARGET(0x8002CDCC,0x8002CE04,ZZ_2CDCC); 39 | ZZ_MARK_TARGET(0x8002CE04,0x8002CE28,ZZ_2CDCC_38); 40 | -------------------------------------------------------------------------------- /srczz/zz_5456c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_5456C: 3 | SP -= 24; 4 | A0 <<= 16; 5 | A0 = (int32_t)A0 >> 16; 6 | V1 = A0 << 2; 7 | A1 <<= 16; 8 | A1 = (int32_t)A1 >> 16; 9 | V0 = A1 << 1; 10 | V0 += A1; 11 | V0 <<= 2; 12 | V0 = V0 - A1; 13 | EMU_Write32(SP + 20,RA); //+ 0x14 14 | EMU_Write32(SP + 16,S0); //+ 0x10 15 | AT = 0x80070000; 16 | AT += V1; 17 | S0 = EMU_ReadU32(AT - 15268); //+ 0xFFFFC45C 18 | V0 <<= 4; 19 | S0 += V0; 20 | V0 = EMU_ReadU8(S0 + 23); //+ 0x17 21 | V0 += S0; 22 | RA = 0x800545C4; //ZZ_5456C_58 23 | EMU_Write8(V0 + 55,A2); //+ 0x37 24 | ZZ_CLOCKCYCLES(22,0x800545DC); 25 | goto ZZ_545DC; 26 | ZZ_5456C_58: 27 | EMU_Write32(S0 + 144,V0); //+ 0x90 28 | RA = EMU_ReadU32(SP + 20); //+ 0x14 29 | S0 = EMU_ReadU32(SP + 16); //+ 0x10 30 | SP += 24; 31 | ZZ_JUMPREGISTER_BEGIN(RA); 32 | ZZ_CLOCKCYCLES_JR(6); 33 | ZZ_JUMPREGISTER_END(); 34 | #endif 35 | ZZ_MARK_TARGET(0x8005456C,0x800545C4,ZZ_5456C); 36 | ZZ_MARK_TARGET(0x800545C4,0x800545DC,ZZ_5456C_58); 37 | -------------------------------------------------------------------------------- /srczz/zz_116c0.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_116C0: 3 | V0 = EMU_ReadU32(A0 - 4); //+ 0xFFFFFFFC 4 | V0 |= 0x1; 5 | ZZ_JUMPREGISTER_BEGIN(RA); 6 | EMU_Write32(A0 - 4,V0); //+ 0xFFFFFFFC 7 | ZZ_CLOCKCYCLES_JR(5); 8 | ZZ_JUMPREGISTER(0x80029A54,ZZ_29A3C_18); 9 | ZZ_JUMPREGISTER(0x8001F238,ZZ_1F220_18); 10 | ZZ_JUMPREGISTER(0x80029A64,ZZ_29A3C_28); 11 | ZZ_JUMPREGISTER(0x80027E38,ZZ_27E10_28); 12 | ZZ_JUMPREGISTER(0x8001F250,ZZ_1F220_30); 13 | ZZ_JUMPREGISTER(0x8001646C,ZZ_1642C_40); 14 | ZZ_JUMPREGISTER(0x80027E5C,ZZ_27E10_4C); 15 | ZZ_JUMPREGISTER(0x80016494,ZZ_1642C_68); 16 | ZZ_JUMPREGISTER(0x80036744,ZZ_36714_30); 17 | ZZ_JUMPREGISTER(0x80031DC4,ZZ_319F8_3CC); 18 | ZZ_JUMPREGISTER(0x8001542C,ZZ_15340_EC); 19 | ZZ_JUMPREGISTER(0x80015438,ZZ_15340_F8); 20 | ZZ_JUMPREGISTER(0x80011748,ZZ_116D4_74); 21 | ZZ_JUMPREGISTER(0x80015444,ZZ_15340_104); 22 | ZZ_JUMPREGISTER(0x80031DB4,ZZ_319F8_3BC); 23 | ZZ_JUMPREGISTER_END(); 24 | #endif 25 | ZZ_MARK_TARGET(0x800116C0,0x800116D4,ZZ_116C0); 26 | -------------------------------------------------------------------------------- /srczz/zz_4e2a8.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4E2A8: 3 | SP -= 8; 4 | A2 = A1 - 1; 5 | V1 = 0x80060000; 6 | V1 = EMU_ReadU32(V1 - 8056); //+ 0xFFFFE088 7 | V0 = 0x4000000; 8 | EMU_Write32(V1,V0); 9 | if (!A1) 10 | { 11 | V0 = R0; 12 | ZZ_CLOCKCYCLES(8,0x8004E2EC); 13 | goto ZZ_4E2A8_44; 14 | } 15 | V0 = R0; 16 | A1 = -1; 17 | ZZ_CLOCKCYCLES(9,0x8004E2CC); 18 | ZZ_4E2A8_24: 19 | V1 = EMU_ReadU32(A0); 20 | A0 += 4; 21 | V0 = 0x80060000; 22 | V0 = EMU_ReadU32(V0 - 8060); //+ 0xFFFFE084 23 | A2 -= 1; 24 | EMU_Write32(V0,V1); 25 | if (A2 != A1) 26 | { 27 | V0 = R0; 28 | ZZ_CLOCKCYCLES(8,0x8004E2CC); 29 | goto ZZ_4E2A8_24; 30 | } 31 | V0 = R0; 32 | ZZ_CLOCKCYCLES(8,0x8004E2EC); 33 | ZZ_4E2A8_44: 34 | SP += 8; 35 | ZZ_JUMPREGISTER_BEGIN(RA); 36 | ZZ_CLOCKCYCLES_JR(3); 37 | ZZ_JUMPREGISTER_END(); 38 | #endif 39 | ZZ_MARK_TARGET(0x8004E2A8,0x8004E2CC,ZZ_4E2A8); 40 | ZZ_MARK_TARGET(0x8004E2CC,0x8004E2EC,ZZ_4E2A8_24); 41 | ZZ_MARK_TARGET(0x8004E2EC,0x8004E2F8,ZZ_4E2A8_44); 42 | -------------------------------------------------------------------------------- /srczz/zz_1a14c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_1A14C: 3 | A1 = EMU_ReadU32(GP + 572); //+ 0x23C 4 | SP -= 8; 5 | if ((int32_t)A1 <= 0) 6 | { 7 | V1 = R0; 8 | ZZ_CLOCKCYCLES(4,0x8001A180); 9 | goto ZZ_1A14C_34; 10 | } 11 | V1 = R0; 12 | A2 = 0x13B; 13 | A0 = R0; 14 | ZZ_CLOCKCYCLES(6,0x8001A164); 15 | ZZ_1A14C_18: 16 | AT = 0x80060000; 17 | AT += A0; 18 | EMU_Write32(AT + 13004,A2); //+ 0x32CC 19 | V1 += 1; 20 | V0 = (int32_t)V1 < (int32_t)A1; 21 | if (V0) 22 | { 23 | A0 += 12; 24 | ZZ_CLOCKCYCLES(7,0x8001A164); 25 | goto ZZ_1A14C_18; 26 | } 27 | A0 += 12; 28 | ZZ_CLOCKCYCLES(7,0x8001A180); 29 | ZZ_1A14C_34: 30 | SP += 8; 31 | ZZ_JUMPREGISTER_BEGIN(RA); 32 | ZZ_CLOCKCYCLES_JR(3); 33 | ZZ_JUMPREGISTER(0x8002FB14,ZZ_2F9D4_140); 34 | ZZ_JUMPREGISTER(0x80020624,ZZ_20304_320); 35 | ZZ_JUMPREGISTER_END(); 36 | #endif 37 | ZZ_MARK_TARGET(0x8001A14C,0x8001A164,ZZ_1A14C); 38 | ZZ_MARK_TARGET(0x8001A164,0x8001A180,ZZ_1A14C_18); 39 | ZZ_MARK_TARGET(0x8001A180,0x8001A18C,ZZ_1A14C_34); 40 | -------------------------------------------------------------------------------- /srcdisasm/PSXDiscompile.sln: -------------------------------------------------------------------------------- 1 | 2 | Microsoft Visual Studio Solution File, Format Version 9.00 3 | # Visual C# Express 2005 4 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PSXDiscompile", "PSXDiscompile.csproj", "{C561AA01-C54F-4B9C-962C-1D6B637DF4D7}" 5 | EndProject 6 | Global 7 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 8 | Debug|Any CPU = Debug|Any CPU 9 | Release|Any CPU = Release|Any CPU 10 | EndGlobalSection 11 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 12 | {C561AA01-C54F-4B9C-962C-1D6B637DF4D7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU 13 | {C561AA01-C54F-4B9C-962C-1D6B637DF4D7}.Debug|Any CPU.Build.0 = Debug|Any CPU 14 | {C561AA01-C54F-4B9C-962C-1D6B637DF4D7}.Release|Any CPU.ActiveCfg = Release|Any CPU 15 | {C561AA01-C54F-4B9C-962C-1D6B637DF4D7}.Release|Any CPU.Build.0 = Release|Any CPU 16 | EndGlobalSection 17 | GlobalSection(SolutionProperties) = preSolution 18 | HideSolutionNode = FALSE 19 | EndGlobalSection 20 | EndGlobal 21 | -------------------------------------------------------------------------------- /srczz/zz_4eec8.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4EEC8: 3 | AT = 0x80060000; 4 | EMU_Write32(AT - 7596,RA); //+ 0xFFFFE254 5 | RA = 0x8004EED8; //ZZ_4EEC8_10 6 | ZZ_CLOCKCYCLES(4,0x8004F490); 7 | goto ZZ_4F490; 8 | ZZ_4EEC8_10: 9 | RA = 0x80060000; 10 | RA = EMU_ReadU32(RA - 7596); //+ 0xFFFFE254 11 | V0 = COP0_GetRegister(12); 12 | V1 = 0x40000000; 13 | V0 |= V1; 14 | COP0_SetRegister(12,V0); 15 | T0 = 341; 16 | GTE_SetRegister(GTE_CREG_ZSF3,T0); 17 | T0 = 256; 18 | GTE_SetRegister(GTE_CREG_ZSF4,T0); 19 | T0 = 1000; 20 | GTE_SetRegister(GTE_CREG_H,T0); 21 | T0 = -4194; 22 | GTE_SetRegister(GTE_CREG_DQA,T0); 23 | T0 = 0x1400000; 24 | GTE_SetRegister(GTE_CREG_DQB,T0); 25 | GTE_SetRegister(GTE_CREG_OFX,R0); 26 | GTE_SetRegister(GTE_CREG_OFY,R0); 27 | ZZ_JUMPREGISTER_BEGIN(RA); 28 | ZZ_CLOCKCYCLES_JR(28); 29 | ZZ_JUMPREGISTER(0x8001576C,ZZ_15738_34); 30 | ZZ_JUMPREGISTER_END(); 31 | #endif 32 | ZZ_MARK_TARGET(0x8004EEC8,0x8004EED8,ZZ_4EEC8); 33 | ZZ_MARK_TARGET(0x8004EED8,0x8004EF48,ZZ_4EEC8_10); 34 | -------------------------------------------------------------------------------- /srczz/zz_4b080.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4B080: 3 | SP -= 24; 4 | A0 = 0x80060000; 5 | A0 -= 8432; 6 | V1 = 0x80060000; 7 | V1 = EMU_ReadU32(V1 - 8396); //+ 0xFFFFDF34 8 | V0 = 263; 9 | EMU_Write32(SP + 16,RA); //+ 0x10 10 | EMU_Write32(V1,V0); 11 | AT = 0x80060000; 12 | EMU_Write32(AT - 8400,R0); //+ 0xFFFFDF30 13 | RA = 0x8004B0B0; //ZZ_4B080_30 14 | A1 = 8; 15 | ZZ_CLOCKCYCLES(12,0x8004B17C); 16 | goto ZZ_4B17C; 17 | ZZ_4B080_30: 18 | A1 = 0x80050000; 19 | A1 -= 20264; 20 | RA = 0x8004B0C0; //ZZ_4B080_40 21 | A0 = R0; 22 | ZZ_CLOCKCYCLES(4,0x8004A940); 23 | goto ZZ_4A940; 24 | ZZ_4B080_40: 25 | V0 = 0x80050000; 26 | V0 -= 20144; 27 | RA = EMU_ReadU32(SP + 16); //+ 0x10 28 | SP += 24; 29 | ZZ_JUMPREGISTER_BEGIN(RA); 30 | ZZ_CLOCKCYCLES_JR(6); 31 | ZZ_JUMPREGISTER(0x8004AB44,ZZ_4AAA8_9C); 32 | ZZ_JUMPREGISTER_END(); 33 | #endif 34 | ZZ_MARK_TARGET(0x8004B080,0x8004B0B0,ZZ_4B080); 35 | ZZ_MARK_TARGET(0x8004B0B0,0x8004B0C0,ZZ_4B080_30); 36 | ZZ_MARK_TARGET(0x8004B0C0,0x8004B0D8,ZZ_4B080_40); 37 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Bitshift/SLLVInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class SLLVInstruction : Instruction 6 | { 7 | private Register rs; 8 | private Register rt; 9 | private Register rd; 10 | 11 | public SLLVInstruction(Register rs,Register rt,Register rd) 12 | { 13 | this.rs = rs; 14 | this.rt = rt; 15 | this.rd = rd; 16 | } 17 | 18 | public override string ToString() 19 | { 20 | return string.Format("SLLV ${0},${1},${2}",rd,rt,rs); 21 | } 22 | 23 | public override void Discompile(Program p,int address,bool direct) 24 | { 25 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 26 | if (rt == rd) 27 | p.WriteLine("{0} <<= {1};",rd,rs); 28 | else 29 | p.WriteLine("{0} = {1} << {2};",rd,rt,rs); 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Bitshift/SRLVInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class SRLVInstruction : Instruction 6 | { 7 | private Register rs; 8 | private Register rt; 9 | private Register rd; 10 | 11 | public SRLVInstruction(Register rs,Register rt,Register rd) 12 | { 13 | this.rs = rs; 14 | this.rt = rt; 15 | this.rd = rd; 16 | } 17 | 18 | public override string ToString() 19 | { 20 | return string.Format("SRLV ${0},${1},${2}",rd,rt,rs); 21 | } 22 | 23 | public override void Discompile(Program p,int address,bool direct) 24 | { 25 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 26 | if (rt == rd) 27 | p.WriteLine("{0} >>= {1};",rd,rs); 28 | else 29 | p.WriteLine("{0} = {1} >> {2};",rd,rt,rs); 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Bitwise/ANDIInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class ANDIInstruction : Instruction 6 | { 7 | private Register rs; 8 | private Register rd; 9 | private int imm; 10 | 11 | public ANDIInstruction(Register rs,Register rd,int imm) 12 | { 13 | this.rs = rs; 14 | this.rd = rd; 15 | this.imm = imm; 16 | } 17 | 18 | public override string ToString() 19 | { 20 | return string.Format("ANDI ${0},${1},{2}",rd,rs,imm); 21 | } 22 | 23 | public override void Discompile(Program p,int address,bool direct) 24 | { 25 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 26 | if (rs == rd) 27 | p.WriteLine("{0} &= 0x{1:X};",rd,imm); 28 | else 29 | p.WriteLine("{0} = {1} & 0x{2:X};",rd,rs,imm); 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Bitwise/XORIInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class XORIInstruction : Instruction 6 | { 7 | private Register rs; 8 | private Register rd; 9 | private int imm; 10 | 11 | public XORIInstruction(Register rs,Register rd,int imm) 12 | { 13 | this.rs = rs; 14 | this.rd = rd; 15 | this.imm = imm; 16 | } 17 | 18 | public override string ToString() 19 | { 20 | return string.Format("XORI ${0},${1},{2}",rd,rs,imm); 21 | } 22 | 23 | public override void Discompile(Program p,int address,bool direct) 24 | { 25 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 26 | if (rs == rd) 27 | p.WriteLine("{0} ^= 0x{1:X};",rd,imm); 28 | else 29 | p.WriteLine("{0} = {1} ^ 0x{2:X};",rd,rs,imm); 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /srczz/zz_48504.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_48504: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | AT = 0x80060000; 6 | EMU_Write32(AT - 13720,R0); //+ 0xFFFFCA68 7 | AT = 0x80060000; 8 | EMU_Write32(AT - 13724,R0); //+ 0xFFFFCA64 9 | AT = 0x80060000; 10 | EMU_Write32(AT - 13704,R0); //+ 0xFFFFCA78 11 | AT = 0x80060000; 12 | EMU_Write32(AT - 13708,R0); //+ 0xFFFFCA74 13 | RA = 0x80048534; //ZZ_48504_30 14 | ZZ_CLOCKCYCLES(12,0x8004A910); 15 | goto ZZ_4A910; 16 | ZZ_48504_30: 17 | A1 = 0x80050000; 18 | A1 -= 30036; 19 | RA = 0x80048544; //ZZ_48504_40 20 | A0 = 2; 21 | ZZ_CLOCKCYCLES(4,0x8004A940); 22 | goto ZZ_4A940; 23 | ZZ_48504_40: 24 | RA = EMU_ReadU32(SP + 16); //+ 0x10 25 | SP += 24; 26 | ZZ_JUMPREGISTER_BEGIN(RA); 27 | ZZ_CLOCKCYCLES_JR(4); 28 | ZZ_JUMPREGISTER(0x80046C8C,ZZ_46C6C_20); 29 | ZZ_JUMPREGISTER_END(); 30 | #endif 31 | ZZ_MARK_TARGET(0x80048504,0x80048534,ZZ_48504); 32 | ZZ_MARK_TARGET(0x80048534,0x80048544,ZZ_48504_30); 33 | ZZ_MARK_TARGET(0x80048544,0x80048554,ZZ_48504_40); 34 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Bitshift/SLLInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class SLLInstruction : Instruction 6 | { 7 | private Register rt; 8 | private Register rd; 9 | private int shamt; 10 | 11 | public SLLInstruction(Register rt,Register rd,int shamt) 12 | { 13 | this.rt = rt; 14 | this.rd = rd; 15 | this.shamt = shamt; 16 | } 17 | 18 | public override string ToString() 19 | { 20 | return string.Format("SLL ${0},${1},{2}",rd,rt,shamt); 21 | } 22 | 23 | public override void Discompile(Program p,int address,bool direct) 24 | { 25 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 26 | if (rt == rd) 27 | p.WriteLine("{0} <<= {1};",rd,shamt); 28 | else 29 | p.WriteLine("{0} = {1} << {2};",rd,rt,shamt); 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Bitshift/SRLInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class SRLInstruction : Instruction 6 | { 7 | private Register rt; 8 | private Register rd; 9 | private int shamt; 10 | 11 | public SRLInstruction(Register rt,Register rd,int shamt) 12 | { 13 | this.rt = rt; 14 | this.rd = rd; 15 | this.shamt = shamt; 16 | } 17 | 18 | public override string ToString() 19 | { 20 | return string.Format("SRL ${0},${1},{2}",rd,rt,shamt); 21 | } 22 | 23 | public override void Discompile(Program p,int address,bool direct) 24 | { 25 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 26 | if (rt == rd) 27 | p.WriteLine("{0} >>= {1};",rd,shamt); 28 | else 29 | p.WriteLine("{0} = {1} >> {2};",rd,rt,shamt); 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Arithmetic/SUBUInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class SUBUInstruction : Instruction 6 | { 7 | private Register rs; 8 | private Register rt; 9 | private Register rd; 10 | 11 | public SUBUInstruction(Register rs,Register rt,Register rd) 12 | { 13 | this.rs = rs; 14 | this.rt = rt; 15 | this.rd = rd; 16 | } 17 | 18 | public override string ToString() 19 | { 20 | return string.Format("SUBU ${0},${1},${2}",rd,rs,rt); 21 | } 22 | 23 | public override void Discompile(Program p,int address,bool direct) 24 | { 25 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 26 | if (rs == Register.R0) 27 | p.WriteLine("{0} = -{1};",rd,rt); 28 | else 29 | p.WriteLine("{0} = {1} - {2};",rd,rs,rt); 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /srczz/zz_4ee84.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4EE84: 3 | SP -= 8; 4 | if (!A2) 5 | { 6 | V0 = A2 - 1; 7 | ZZ_CLOCKCYCLES(3,0x8004EEA4); 8 | goto ZZ_4EE84_20; 9 | } 10 | V0 = A2 - 1; 11 | V1 = -1; 12 | ZZ_CLOCKCYCLES(4,0x8004EE94); 13 | ZZ_4EE84_10: 14 | EMU_Write8(A0,A1); 15 | V0 -= 1; 16 | if (V0 != V1) 17 | { 18 | A0 += 1; 19 | ZZ_CLOCKCYCLES(4,0x8004EE94); 20 | goto ZZ_4EE84_10; 21 | } 22 | A0 += 1; 23 | ZZ_CLOCKCYCLES(4,0x8004EEA4); 24 | ZZ_4EE84_20: 25 | SP += 8; 26 | ZZ_JUMPREGISTER_BEGIN(RA); 27 | ZZ_CLOCKCYCLES_JR(3); 28 | ZZ_JUMPREGISTER(0x8004BEA4,ZZ_4BE1C_88); 29 | ZZ_JUMPREGISTER(0x8004BF1C,ZZ_4BE1C_100); 30 | ZZ_JUMPREGISTER(0x8004BF2C,ZZ_4BE1C_110); 31 | ZZ_JUMPREGISTER(0x8004EA20,ZZ_4E964_BC); 32 | ZZ_JUMPREGISTER(0x8004EA34,ZZ_4E964_D0); 33 | ZZ_JUMPREGISTER(0x8004C29C,ZZ_4C240_5C); 34 | ZZ_JUMPREGISTER_END(); 35 | #endif 36 | ZZ_MARK_TARGET(0x8004EE84,0x8004EE94,ZZ_4EE84); 37 | ZZ_MARK_TARGET(0x8004EE94,0x8004EEA4,ZZ_4EE84_10); 38 | ZZ_MARK_TARGET(0x8004EEA4,0x8004EEB0,ZZ_4EE84_20); 39 | -------------------------------------------------------------------------------- /srczz/zz_5b320.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_5B320: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | RA = 0x8005B330; //ZZ_5B320_10 6 | ZZ_CLOCKCYCLES(4,0x80049FB4); 7 | goto ZZ_49FB4; 8 | ZZ_5B320_10: 9 | RA = 0x8005B338; //ZZ_5B320_18 10 | ZZ_CLOCKCYCLES(2,0x8005B390); 11 | goto ZZ_5B390; 12 | ZZ_5B320_18: 13 | RA = 0x8005B340; //ZZ_5B320_20 14 | A0 = R0; 15 | ZZ_CLOCKCYCLES(2,0x8004A054); 16 | goto ZZ_4A054; 17 | ZZ_5B320_20: 18 | RA = 0x8005B348; //ZZ_5B320_28 19 | ZZ_CLOCKCYCLES(2,0x80049FC4); 20 | goto ZZ_49FC4; 21 | ZZ_5B320_28: 22 | RA = EMU_ReadU32(SP + 16); //+ 0x10 23 | SP += 24; 24 | ZZ_JUMPREGISTER_BEGIN(RA); 25 | ZZ_CLOCKCYCLES_JR(4); 26 | ZZ_JUMPREGISTER(0x800365C0,ZZ_364A8_118); 27 | ZZ_JUMPREGISTER_END(); 28 | #endif 29 | ZZ_MARK_TARGET(0x8005B320,0x8005B330,ZZ_5B320); 30 | ZZ_MARK_TARGET(0x8005B330,0x8005B338,ZZ_5B320_10); 31 | ZZ_MARK_TARGET(0x8005B338,0x8005B340,ZZ_5B320_18); 32 | ZZ_MARK_TARGET(0x8005B340,0x8005B348,ZZ_5B320_20); 33 | ZZ_MARK_TARGET(0x8005B348,0x8005B358,ZZ_5B320_28); 34 | -------------------------------------------------------------------------------- /srczz/zz_130fc.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_130FC: 3 | V0 = -1; 4 | if (A1 != V0) 5 | { 6 | A1 = (int32_t)A1 >> 1; 7 | ZZ_CLOCKCYCLES(3,0x80013110); 8 | goto ZZ_130FC_14; 9 | } 10 | A1 = (int32_t)A1 >> 1; 11 | V0 = 0x1; 12 | ZZ_CLOCKCYCLES(5,0x80013140); 13 | goto ZZ_130FC_44; 14 | ZZ_130FC_14: 15 | V0 = EMU_ReadU32(A0 + 36); //+ 0x24 16 | V1 = EMU_ReadU32(V0 + 20); //+ 0x14 17 | A2 = (int32_t)V1 >> 1; 18 | V1 = (int32_t)A2 < (int32_t)A1; 19 | if (V1) 20 | { 21 | V0 = R0; 22 | ZZ_CLOCKCYCLES(8,0x80013140); 23 | goto ZZ_130FC_44; 24 | } 25 | V0 = R0; 26 | V0 = EMU_ReadU32(A0 + 28); //+ 0x1C 27 | V0 = A2 - V0; 28 | V0 = (int32_t)V0 < (int32_t)A1; 29 | ZZ_CLOCKCYCLES(12,0x80013140); 30 | ZZ_130FC_44: 31 | ZZ_JUMPREGISTER_BEGIN(RA); 32 | ZZ_CLOCKCYCLES_JR(2); 33 | ZZ_JUMPREGISTER(0x800133D4,ZZ_13304_D0); 34 | ZZ_JUMPREGISTER_END(); 35 | #endif 36 | ZZ_MARK_TARGET(0x800130FC,0x80013110,ZZ_130FC); 37 | ZZ_MARK_TARGET(0x80013110,0x80013140,ZZ_130FC_14); 38 | ZZ_MARK_TARGET(0x80013140,0x80013148,ZZ_130FC_44); 39 | -------------------------------------------------------------------------------- /srczz/zz_36714.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_36714: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,RA); //+ 0x10 5 | RA = 0x80036724; //ZZ_36714_10 6 | ZZ_CLOCKCYCLES(4,0x80036494); 7 | goto ZZ_36494; 8 | ZZ_36714_10: 9 | A0 = EMU_ReadU32(GP + 232); //+ 0xE8 10 | V0 >>= 4; 11 | V0 &= 0x1; 12 | EMU_Write32(GP + 236,V0); //+ 0xEC 13 | if (!A0) 14 | { 15 | ZZ_CLOCKCYCLES(6,0x80036748); 16 | goto ZZ_36714_34; 17 | } 18 | RA = 0x80036744; //ZZ_36714_30 19 | ZZ_CLOCKCYCLES(8,0x800116C0); 20 | goto ZZ_116C0; 21 | ZZ_36714_30: 22 | EMU_Write32(GP + 232,R0); //+ 0xE8 23 | ZZ_CLOCKCYCLES(1,0x80036748); 24 | ZZ_36714_34: 25 | RA = EMU_ReadU32(SP + 16); //+ 0x10 26 | V0 = R0; 27 | ZZ_JUMPREGISTER_BEGIN(RA); 28 | SP += 24; 29 | ZZ_CLOCKCYCLES_JR(4); 30 | ZZ_JUMPREGISTER(0x800164C4,ZZ_1642C_98); 31 | ZZ_JUMPREGISTER_END(); 32 | #endif 33 | ZZ_MARK_TARGET(0x80036714,0x80036724,ZZ_36714); 34 | ZZ_MARK_TARGET(0x80036724,0x80036744,ZZ_36714_10); 35 | ZZ_MARK_TARGET(0x80036744,0x80036748,ZZ_36714_30); 36 | ZZ_MARK_TARGET(0x80036748,0x80036758,ZZ_36714_34); 37 | -------------------------------------------------------------------------------- /srczz/zz_4a940.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A940: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU32(V0 - 8452); //+ 0xFFFFDEFC 5 | SP -= 24; 6 | EMU_Write32(SP + 16,RA); //+ 0x10 7 | V0 = EMU_ReadU32(V0 + 8); //+ 0x8 8 | ZZ_JUMPREGISTER_BEGIN(V0); 9 | RA = 0x8004A960; //ZZ_4A940_20 10 | ZZ_CLOCKCYCLES_JR(8); 11 | // UNIMPLEMENTED JUMP-TO-REGISTER-AND-LINK (V0,8004A958) 12 | ZZ_JUMPREGISTER_END(); 13 | ZZ_4A940_20: 14 | RA = EMU_ReadU32(SP + 16); //+ 0x10 15 | SP += 24; 16 | ZZ_JUMPREGISTER_BEGIN(RA); 17 | ZZ_CLOCKCYCLES_JR(4); 18 | ZZ_JUMPREGISTER(0x80052EB8,ZZ_52E18_A0); 19 | ZZ_JUMPREGISTER(0x80052EA0,ZZ_52E18_88); 20 | ZZ_JUMPREGISTER(0x80048544,ZZ_48504_40); 21 | ZZ_JUMPREGISTER(0x800485CC,ZZ_48554_78); 22 | ZZ_JUMPREGISTER(0x80055064,ZZ_54E64_200); 23 | ZZ_JUMPREGISTER(0x800550AC,ZZ_54E64_248); 24 | ZZ_JUMPREGISTER(0x8004B0C0,ZZ_4B080_40); 25 | ZZ_JUMPREGISTER(0x8004B1E0,ZZ_4B1A8_38); 26 | ZZ_JUMPREGISTER_END(); 27 | #endif 28 | ZZ_MARK_TARGET(0x8004A940,0x8004A960,ZZ_4A940); 29 | ZZ_MARK_TARGET(0x8004A960,0x8004A970,ZZ_4A940_20); 30 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Memory/Unaligned/LWLInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class LWLInstruction : Instruction 6 | { 7 | private Register rs; 8 | private Register rd; 9 | private int imm; 10 | 11 | public LWLInstruction(Register rs,Register rd,int imm) 12 | { 13 | this.rs = rs; 14 | this.rd = rd; 15 | this.imm = imm; 16 | } 17 | 18 | public override string ToString() 19 | { 20 | return string.Format("LWL ${0},{2}(${1})",rd,rs,imm); 21 | } 22 | 23 | public override void Discompile(Program p,int address,bool direct) 24 | { 25 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 26 | if (imm == 0) 27 | p.WriteLine("EMU_ReadLeft({0},&{1});",rs,rd); 28 | else 29 | p.WriteLine("EMU_ReadLeft({0} + {1},&{2}); //+ 0x{1:X}",rs,imm,rd); 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Memory/Unaligned/LWRInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class LWRInstruction : Instruction 6 | { 7 | private Register rs; 8 | private Register rd; 9 | private int imm; 10 | 11 | public LWRInstruction(Register rs,Register rd,int imm) 12 | { 13 | this.rs = rs; 14 | this.rd = rd; 15 | this.imm = imm; 16 | } 17 | 18 | public override string ToString() 19 | { 20 | return string.Format("LWR ${0},{2}(${1})",rd,rs,imm); 21 | } 22 | 23 | public override void Discompile(Program p,int address,bool direct) 24 | { 25 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 26 | if (imm == 0) 27 | p.WriteLine("EMU_ReadRight({0},&{1});",rs,rd); 28 | else 29 | p.WriteLine("EMU_ReadRight({0} + {1},&{2}); //+ 0x{1:X}",rs,imm,rd); 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Memory/Unaligned/SWLInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class SWLInstruction : Instruction 6 | { 7 | private Register rs; 8 | private Register rt; 9 | private int imm; 10 | 11 | public SWLInstruction(Register rs,Register rt,int imm) 12 | { 13 | this.rs = rs; 14 | this.rt = rt; 15 | this.imm = imm; 16 | } 17 | 18 | public override string ToString() 19 | { 20 | return string.Format("SWL ${0},{2}(${1})",rt,rs,imm); 21 | } 22 | 23 | public override void Discompile(Program p,int address,bool direct) 24 | { 25 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 26 | if (imm == 0) 27 | p.WriteLine("EMU_WriteLeft({0},{1});",rs,rt); 28 | else 29 | p.WriteLine("EMU_WriteLeft({0} + {1},{2}); //+ 0x{1:X}",rs,imm,rt); 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Memory/Unaligned/SWRInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class SWRInstruction : Instruction 6 | { 7 | private Register rs; 8 | private Register rt; 9 | private int imm; 10 | 11 | public SWRInstruction(Register rs,Register rt,int imm) 12 | { 13 | this.rs = rs; 14 | this.rt = rt; 15 | this.imm = imm; 16 | } 17 | 18 | public override string ToString() 19 | { 20 | return string.Format("SWR ${0},{2}(${1})",rt,rs,imm); 21 | } 22 | 23 | public override void Discompile(Program p,int address,bool direct) 24 | { 25 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 26 | if (imm == 0) 27 | p.WriteLine("EMU_WriteRight({0},{1});",rs,rt); 28 | else 29 | p.WriteLine("EMU_WriteRight({0} + {1},{2}); //+ 0x{1:X}",rs,imm,rt); 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /srczz/zz_36270.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_36270: 3 | SP -= 24; 4 | EMU_Write32(SP + 16,S0); //+ 0x10 5 | S0 = A0; 6 | EMU_Write32(SP + 20,RA); //+ 0x14 7 | A0 = EMU_ReadU32(S0); 8 | if ((int32_t)A0 < 0) 9 | { 10 | V0 = -1; 11 | ZZ_CLOCKCYCLES(8,0x8003629C); 12 | goto ZZ_36270_2C; 13 | } 14 | V0 = -1; 15 | RA = 0x80036298; //ZZ_36270_28 16 | ZZ_CLOCKCYCLES(10,0x8004A004); 17 | goto ZZ_4A004; 18 | ZZ_36270_28: 19 | V0 = -1; 20 | ZZ_CLOCKCYCLES(1,0x8003629C); 21 | ZZ_36270_2C: 22 | EMU_Write32(S0,V0); 23 | RA = EMU_ReadU32(SP + 20); //+ 0x14 24 | S0 = EMU_ReadU32(SP + 16); //+ 0x10 25 | SP += 24; 26 | ZZ_JUMPREGISTER_BEGIN(RA); 27 | ZZ_CLOCKCYCLES_JR(6); 28 | ZZ_JUMPREGISTER(0x80035A88,ZZ_3578C_2FC); 29 | ZZ_JUMPREGISTER(0x80034DF8,ZZ_34D74_84); 30 | ZZ_JUMPREGISTER(0x80035370,ZZ_34F00_470); 31 | ZZ_JUMPREGISTER(0x80035CF0,ZZ_3578C_564); 32 | ZZ_JUMPREGISTER_END(); 33 | #endif 34 | ZZ_MARK_TARGET(0x80036270,0x80036298,ZZ_36270); 35 | ZZ_MARK_TARGET(0x80036298,0x8003629C,ZZ_36270_28); 36 | ZZ_MARK_TARGET(0x8003629C,0x800362B4,ZZ_36270_2C); 37 | -------------------------------------------------------------------------------- /srczz/zz_17028.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_17028: 3 | V0 = (int32_t)A0 < 22; 4 | if (!V0) 5 | { 6 | ZZ_CLOCKCYCLES(3,0x8001703C); 7 | goto ZZ_17028_14; 8 | } 9 | A0 = 0x14; 10 | ZZ_CLOCKCYCLES(5,0x80017060); 11 | goto ZZ_17028_38; 12 | ZZ_17028_14: 13 | V0 = (int32_t)A0 < 43; 14 | if (!V0) 15 | { 16 | ZZ_CLOCKCYCLES(3,0x80017050); 17 | goto ZZ_17028_28; 18 | } 19 | A0 = 0x29; 20 | ZZ_CLOCKCYCLES(5,0x80017060); 21 | goto ZZ_17028_38; 22 | ZZ_17028_28: 23 | V0 = (int32_t)A0 < 63; 24 | if (!V0) 25 | { 26 | A0 = 0x52; 27 | ZZ_CLOCKCYCLES(3,0x80017060); 28 | goto ZZ_17028_38; 29 | } 30 | A0 = 0x52; 31 | A0 = 0x3D; 32 | ZZ_CLOCKCYCLES(4,0x80017060); 33 | ZZ_17028_38: 34 | ZZ_JUMPREGISTER_BEGIN(RA); 35 | V0 = A0; 36 | ZZ_CLOCKCYCLES_JR(2); 37 | ZZ_JUMPREGISTER(0x80016AAC,ZZ_1658C_520); 38 | ZZ_JUMPREGISTER_END(); 39 | #endif 40 | ZZ_MARK_TARGET(0x80017028,0x8001703C,ZZ_17028); 41 | ZZ_MARK_TARGET(0x8001703C,0x80017050,ZZ_17028_14); 42 | ZZ_MARK_TARGET(0x80017050,0x80017060,ZZ_17028_28); 43 | ZZ_MARK_TARGET(0x80017060,0x80017068,ZZ_17028_38); 44 | -------------------------------------------------------------------------------- /srczz/zz_362e0.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_362E0: 3 | V1 = EMU_ReadU8(A0); 4 | if (!V1) 5 | { 6 | V0 = V1 - 97; 7 | ZZ_CLOCKCYCLES(4,0x80036314); 8 | goto ZZ_362E0_34; 9 | } 10 | V0 = V1 - 97; 11 | ZZ_CLOCKCYCLES(4,0x800362F0); 12 | ZZ_362E0_10: 13 | V0 = V0 < 26; 14 | if (!V0) 15 | { 16 | V0 = V1 - 32; 17 | ZZ_CLOCKCYCLES(3,0x80036300); 18 | goto ZZ_362E0_20; 19 | } 20 | V0 = V1 - 32; 21 | EMU_Write8(A0,V0); 22 | ZZ_CLOCKCYCLES(4,0x80036300); 23 | ZZ_362E0_20: 24 | A0 += 1; 25 | V1 = EMU_ReadU8(A0); 26 | if (V1) 27 | { 28 | V0 = V1 - 97; 29 | ZZ_CLOCKCYCLES(5,0x800362F0); 30 | goto ZZ_362E0_10; 31 | } 32 | V0 = V1 - 97; 33 | ZZ_CLOCKCYCLES(5,0x80036314); 34 | ZZ_362E0_34: 35 | ZZ_JUMPREGISTER_BEGIN(RA); 36 | ZZ_CLOCKCYCLES_JR(2); 37 | ZZ_JUMPREGISTER(0x800351D8,ZZ_34F00_2D8); 38 | ZZ_JUMPREGISTER_END(); 39 | #endif 40 | ZZ_MARK_TARGET(0x800362E0,0x800362F0,ZZ_362E0); 41 | ZZ_MARK_TARGET(0x800362F0,0x80036300,ZZ_362E0_10); 42 | ZZ_MARK_TARGET(0x80036300,0x80036314,ZZ_362E0_20); 43 | ZZ_MARK_TARGET(0x80036314,0x8003631C,ZZ_362E0_34); 44 | -------------------------------------------------------------------------------- /srczz/zz_45ef4.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_45EF4: 3 | T8 = T5 | T6; 4 | T8 |= T7; 5 | if ((int32_t)T8 >= 0) 6 | { 7 | A0 = 1904; 8 | ZZ_CLOCKCYCLES(4,0x80045F0C); 9 | goto ZZ_45EF4_18; 10 | } 11 | A0 = 1904; 12 | ZZ_JUMPREGISTER_BEGIN(RA); 13 | ZZ_CLOCKCYCLES_JR(6); 14 | ZZ_JUMPREGISTER(0x80046A90,ZZ_46478_618); 15 | ZZ_JUMPREGISTER_END(); 16 | ZZ_45EF4_18: 17 | V0 = A3 + AT; 18 | V0 += S6; 19 | V0 <<= 16; 20 | V0 = (int32_t)V0 >> 16; 21 | T9 = V0 >> 5; 22 | V0 = A0 - T9; 23 | V0 -= 5; 24 | A0 = EMU_CheckedAdd(V0,-1904); 25 | if ((int32_t)A0 < 0) 26 | { 27 | V0 <<= 2; 28 | ZZ_CLOCKCYCLES(10,0x80045F38); 29 | goto ZZ_45EF4_44; 30 | } 31 | V0 <<= 2; 32 | V0 = 7616; 33 | ZZ_CLOCKCYCLES(11,0x80045F38); 34 | ZZ_45EF4_44: 35 | if ((int32_t)V0 >= 0) 36 | { 37 | V0 += FP; 38 | ZZ_CLOCKCYCLES(2,0x80045F44); 39 | goto ZZ_45F44; 40 | } 41 | V0 += FP; 42 | V0 = FP; 43 | #endif 44 | ZZ_MARK_TARGET(0x80045EF4,0x80045F0C,ZZ_45EF4); 45 | ZZ_MARK_TARGET(0x80045F0C,0x80045F38,ZZ_45EF4_18); 46 | ZZ_MARK_TARGET(0x80045F38,0x80045F44,ZZ_45EF4_44); 47 | -------------------------------------------------------------------------------- /srczz/zz_4a454.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4A454: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU32(V0 - 12804); //+ 0xFFFFCDFC 5 | SP -= 16; 6 | EMU_Write16(V0 + 10,R0); //+ 0xA 7 | V0 = 10; 8 | EMU_Write32(SP,V0); 9 | V0 = EMU_ReadU32(SP); 10 | V0 -= 1; 11 | EMU_Write32(SP,V0); 12 | V1 = EMU_ReadU32(SP); 13 | V0 = -1; 14 | if (V1 == V0) 15 | { 16 | V0 = R0; 17 | ZZ_CLOCKCYCLES(14,0x8004A4B0); 18 | goto ZZ_4A454_5C; 19 | } 20 | V0 = R0; 21 | V1 = -1; 22 | ZZ_CLOCKCYCLES(15,0x8004A490); 23 | ZZ_4A454_3C: 24 | V0 = EMU_ReadU32(SP); 25 | V0 -= 1; 26 | EMU_Write32(SP,V0); 27 | V0 = EMU_ReadU32(SP); 28 | if (V0 != V1) 29 | { 30 | V0 = R0; 31 | ZZ_CLOCKCYCLES(8,0x8004A490); 32 | goto ZZ_4A454_3C; 33 | } 34 | V0 = R0; 35 | ZZ_CLOCKCYCLES(8,0x8004A4B0); 36 | ZZ_4A454_5C: 37 | SP += 16; 38 | ZZ_JUMPREGISTER_BEGIN(RA); 39 | ZZ_CLOCKCYCLES_JR(3); 40 | ZZ_JUMPREGISTER_END(); 41 | #endif 42 | ZZ_MARK_TARGET(0x8004A454,0x8004A490,ZZ_4A454); 43 | ZZ_MARK_TARGET(0x8004A490,0x8004A4B0,ZZ_4A454_3C); 44 | ZZ_MARK_TARGET(0x8004A4B0,0x8004A4BC,ZZ_4A454_5C); 45 | -------------------------------------------------------------------------------- /srczz/zz_315d8.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_315D8: 3 | A1 = A1 - A0; 4 | A1 <<= 20; 5 | A1 = (int32_t)A1 >> 20; 6 | EMU_SMultiply(A2,A1); 7 | V1 = LO; 8 | V0 = (int32_t)V1 >> 8; 9 | A0 += V0; 10 | ZZ_JUMPREGISTER_BEGIN(RA); 11 | V0 = A0 & 0xFFF; 12 | ZZ_CLOCKCYCLES_JR(9); 13 | ZZ_JUMPREGISTER(0x80022268,ZZ_221A8_C0); 14 | ZZ_JUMPREGISTER(0x80023588,ZZ_23424_164); 15 | ZZ_JUMPREGISTER(0x800235A0,ZZ_23424_17C); 16 | ZZ_JUMPREGISTER(0x80021E14,ZZ_21C64_1B0); 17 | ZZ_JUMPREGISTER(0x80021E74,ZZ_21C64_210); 18 | ZZ_JUMPREGISTER(0x800235B8,ZZ_23424_194); 19 | ZZ_JUMPREGISTER(0x80021EA0,ZZ_21C64_23C); 20 | ZZ_JUMPREGISTER(0x80023624,ZZ_23424_200); 21 | ZZ_JUMPREGISTER(0x800236D8,ZZ_23424_2B4); 22 | ZZ_JUMPREGISTER(0x800240BC,ZZ_24038_84); 23 | ZZ_JUMPREGISTER(0x800236F0,ZZ_23424_2CC); 24 | ZZ_JUMPREGISTER(0x80023708,ZZ_23424_2E4); 25 | ZZ_JUMPREGISTER(0x80026EB8,ZZ_26C7C_23C); 26 | ZZ_JUMPREGISTER(0x80026ECC,ZZ_26C7C_250); 27 | ZZ_JUMPREGISTER(0x80026EE0,ZZ_26C7C_264); 28 | ZZ_JUMPREGISTER_END(); 29 | #endif 30 | ZZ_MARK_TARGET(0x800315D8,0x800315FC,ZZ_315D8); 31 | -------------------------------------------------------------------------------- /srczz/zz_4330c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_CLOCKCYCLES(41,0x8004330C); 3 | ZZ_4330C: 4 | GTE_SetRegister(GTE_CREG_RT11_RT12,T0); 5 | ZZ_CLOCKCYCLES(1,0x80043310); 6 | ZZ_4330C_4: 7 | GTE_SetRegister(GTE_CREG_RT13_RT21,T1); 8 | GTE_SetRegister(GTE_CREG_RT22_RT23,T2); 9 | GTE_SetRegister(GTE_CREG_RT31_RT32,T3); 10 | GTE_SetRegister(GTE_CREG_RT33_NONE,T4); 11 | ZZ_JUMPREGISTER_BEGIN(RA); 12 | ZZ_CLOCKCYCLES_JR(6); 13 | ZZ_JUMPREGISTER(0x8003DF08,ZZ_3DE2C_DC); 14 | ZZ_JUMPREGISTER(0x800449B8,ZZ_44850_168); 15 | ZZ_JUMPREGISTER(0x80044888,ZZ_44850_38); 16 | ZZ_JUMPREGISTER(0x800442F8,ZZ_43C6C_68C); 17 | ZZ_JUMPREGISTER(0x8004456C,ZZ_43C6C_900); 18 | ZZ_JUMPREGISTER(0x80044624,ZZ_43C6C_9B8); 19 | ZZ_JUMPREGISTER(0x8004446C,ZZ_43C6C_800); 20 | ZZ_JUMPREGISTER(0x8004023C,ZZ_3FFAC_290); 21 | ZZ_JUMPREGISTER(0x800412EC,ZZ_40FAC_340); 22 | ZZ_JUMPREGISTER(0x80044A3C,ZZ_44850_1EC); 23 | ZZ_JUMPREGISTER(0x80044968,ZZ_44850_118); 24 | ZZ_JUMPREGISTER_END(); 25 | #endif 26 | ZZ_MARK_TARGET(0x8004330C,0x80043310,ZZ_4330C); 27 | ZZ_MARK_TARGET(0x80043310,0x80043328,ZZ_4330C_4); 28 | -------------------------------------------------------------------------------- /srczz/zz_14c48.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_14C48: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU32(V0 + 30760); //+ 0x7828 5 | V1 = A0 >> 13; 6 | V1 &= 0x3FC; 7 | V1 += V0; 8 | V1 = EMU_ReadU32(V1); 9 | V0 = EMU_ReadU32(V1 + 4); //+ 0x4 10 | if (V0 == A0) 11 | { 12 | ZZ_CLOCKCYCLES(11,0x80014C8C); 13 | goto ZZ_14C48_44; 14 | } 15 | V1 += 8; 16 | ZZ_CLOCKCYCLES(12,0x80014C78); 17 | ZZ_14C48_30: 18 | V0 = EMU_ReadU32(V1 + 4); //+ 0x4 19 | if (V0 != A0) 20 | { 21 | V1 += 8; 22 | ZZ_CLOCKCYCLES(4,0x80014C78); 23 | goto ZZ_14C48_30; 24 | } 25 | V1 += 8; 26 | V1 -= 8; 27 | ZZ_CLOCKCYCLES(5,0x80014C8C); 28 | ZZ_14C48_44: 29 | ZZ_JUMPREGISTER_BEGIN(RA); 30 | V0 = V1; 31 | ZZ_CLOCKCYCLES_JR(2); 32 | ZZ_JUMPREGISTER(0x800144F4,ZZ_144C4_30); 33 | ZZ_JUMPREGISTER(0x800143B8,ZZ_14364_54); 34 | ZZ_JUMPREGISTER(0x80014A84,ZZ_14A1C_68); 35 | ZZ_JUMPREGISTER(0x800128DC,ZZ_126BC_220); 36 | ZZ_JUMPREGISTER_END(); 37 | #endif 38 | ZZ_MARK_TARGET(0x80014C48,0x80014C78,ZZ_14C48); 39 | ZZ_MARK_TARGET(0x80014C78,0x80014C8C,ZZ_14C48_30); 40 | ZZ_MARK_TARGET(0x80014C8C,0x80014C94,ZZ_14C48_44); 41 | -------------------------------------------------------------------------------- /srczz/zz_4d1e8.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_4D1E8: 3 | SP -= 32; 4 | EMU_Write32(SP + 16,S0); //+ 0x10 5 | S0 = A0; 6 | A0 = A1; 7 | V0 = 2; 8 | A1 = A2; 9 | EMU_Write32(SP + 20,S1); //+ 0x14 10 | S1 = EMU_ReadU32(SP + 48); //+ 0x30 11 | A2 = A3 & 0xFFFF; 12 | EMU_Write32(SP + 24,RA); //+ 0x18 13 | RA = 0x8004D218; //ZZ_4D1E8_30 14 | EMU_Write8(S0 + 3,V0); //+ 0x3 15 | ZZ_CLOCKCYCLES(12,0x8004D6E8); 16 | goto ZZ_4D6E8; 17 | ZZ_4D1E8_30: 18 | EMU_Write32(S0 + 4,V0); //+ 0x4 19 | RA = 0x8004D224; //ZZ_4D1E8_3C 20 | A0 = S1; 21 | ZZ_CLOCKCYCLES(3,0x8004D91C); 22 | goto ZZ_4D91C; 23 | ZZ_4D1E8_3C: 24 | EMU_Write32(S0 + 8,V0); //+ 0x8 25 | RA = EMU_ReadU32(SP + 24); //+ 0x18 26 | S1 = EMU_ReadU32(SP + 20); //+ 0x14 27 | S0 = EMU_ReadU32(SP + 16); //+ 0x10 28 | SP += 32; 29 | ZZ_JUMPREGISTER_BEGIN(RA); 30 | ZZ_CLOCKCYCLES_JR(7); 31 | ZZ_JUMPREGISTER(0x80016D58,ZZ_16C38_120); 32 | ZZ_JUMPREGISTER_END(); 33 | #endif 34 | ZZ_MARK_TARGET(0x8004D1E8,0x8004D218,ZZ_4D1E8); 35 | ZZ_MARK_TARGET(0x8004D218,0x8004D224,ZZ_4D1E8_30); 36 | ZZ_MARK_TARGET(0x8004D224,0x8004D240,ZZ_4D1E8_3C); 37 | -------------------------------------------------------------------------------- /srczz/zz_5510c.h: -------------------------------------------------------------------------------- 1 | #ifdef ZZ_INCLUDE_CODE 2 | ZZ_5510C: 3 | V0 = 0x80060000; 4 | V0 = EMU_ReadU32(V0 - 3460); //+ 0xFFFFF27C 5 | SP -= 24; 6 | if (!V0) 7 | { 8 | EMU_Write32(SP + 16,RA); //+ 0x10 9 | ZZ_CLOCKCYCLES(5,0x80055128); 10 | goto ZZ_5510C_1C; 11 | } 12 | EMU_Write32(SP + 16,RA); //+ 0x10 13 | ZZ_JUMPREGISTER_BEGIN(V0); 14 | RA = 0x80055128; //ZZ_5510C_1C 15 | ZZ_CLOCKCYCLES_JR(7); 16 | // UNIMPLEMENTED JUMP-TO-REGISTER-AND-LINK (V0,80055120) 17 | ZZ_JUMPREGISTER_END(); 18 | ZZ_5510C_1C: 19 | V0 = 0x80060000; 20 | V0 = EMU_ReadU32(V0 - 3464); //+ 0xFFFFF278 21 | ZZ_JUMPREGISTER_BEGIN(V0); 22 | RA = 0x8005513C; //ZZ_5510C_30 23 | ZZ_CLOCKCYCLES_JR(5); 24 | // UNIMPLEMENTED JUMP-TO-REGISTER-AND-LINK (V0,80055134) 25 | ZZ_JUMPREGISTER_END(); 26 | ZZ_5510C_30: 27 | RA = EMU_ReadU32(SP + 16); //+ 0x10 28 | SP += 24; 29 | ZZ_JUMPREGISTER_BEGIN(RA); 30 | ZZ_CLOCKCYCLES_JR(4); 31 | ZZ_JUMPREGISTER_END(); 32 | #endif 33 | ZZ_MARK_TARGET(0x8005510C,0x80055128,ZZ_5510C); 34 | ZZ_MARK_TARGET(0x80055128,0x8005513C,ZZ_5510C_1C); 35 | ZZ_MARK_TARGET(0x8005513C,0x8005514C,ZZ_5510C_30); 36 | -------------------------------------------------------------------------------- /srcdisasm/MIPS/Instructions/Bitwise/ANDInstruction.cs: -------------------------------------------------------------------------------- 1 | using System.IO; 2 | 3 | namespace PSXDiscompile 4 | { 5 | public sealed class ANDInstruction : Instruction 6 | { 7 | private Register rs; 8 | private Register rt; 9 | private Register rd; 10 | 11 | public ANDInstruction(Register rs,Register rt,Register rd) 12 | { 13 | this.rs = rs; 14 | this.rt = rt; 15 | this.rd = rd; 16 | } 17 | 18 | public override string ToString() 19 | { 20 | return string.Format("AND ${0},${1},${2}",rd,rs,rt); 21 | } 22 | 23 | public override void Discompile(Program p,int address,bool direct) 24 | { 25 | //p.WriteLine("ZZ_ONCE(0x{0:X});",address);return; 26 | if (rs == rd) 27 | p.WriteLine("{0} &= {1};",rd,rt); 28 | else if (rt == rd) 29 | p.WriteLine("{0} &= {1};",rd,rs); 30 | else 31 | p.WriteLine("{0} = {1} & {2};",rd,rs,rt); 32 | } 33 | } 34 | } 35 | --------------------------------------------------------------------------------