int main(int argc, char* argv[])
{
struct sigaction sa;
sa.sa_flags = SA_SIGINFO | SA_NODEFER;
sigemptyset(&sa.sa_mask);
sa.sa_sigaction = handler;
sigaction(SIGSEGV, &sa, NULL);
sigaction(SIGABRT, &sa, NULL);
sigaction(SIGILL, &sa, NULL);
sigaction(SIGINT, &sa, NULL);
sigaction(SIGFPE, &sa, NULL);
printf("R4300 Recompiler\n\n");
#ifndef TEST
printf("Opening %s\n",argv[1]);
#endif
FILE *fPtr;
uint32_t romlength = 0U;
#ifndef TEST
if (argc <= 1) fPtr = fopen("m64p_test_rom.v64", "rb");
else fPtr = fopen(argv[1], "rb");
if (fPtr == NULL) return 2;
fseek(fPtr, 0L, SEEK_END);
romlength = ftell(fPtr);
fseek(fPtr, 0L, SEEK_SET);
#else
romlength = 2000U;
#endif
if (mmap((uint32_t*)(MMAP_BASE)
, MMAP_BASE_SIZE + romlength
, PROT_READ|PROT_WRITE|PROT_EXEC
, MAP_PRIVATE| MAP_FIXED | MAP_ANONYMOUS
, -1
, 0 ) != (uint32_t*)(MMAP_BASE))
{
printf("Could not mmap\n");
return 1;
}
if (mmap((uint32_t*)(MMAP_PIF_BOOT_ROM)
, 4096
, PROT_READ|PROT_WRITE|PROT_EXEC
, MAP_PRIVATE| MAP_FIXED | MAP_ANONYMOUS
, -1
, 0 ) != (uint32_t*)(MMAP_PIF_BOOT_ROM))
{
printf("Could not mmap PIF area\n");
return 1;
}
#ifdef TEST
//Generate helper functions
GenerateCodeSegmentData(romlength);
//Start testing
Translation_Test(&segmentData);
#else
unsigned char imagetype;
m64p_rom_header ROM_HEADER;
if (fread((uint32_t*)ROM_ADDRESS , 1, romlength, fPtr) != romlength)
{
printf("could not read ROM\n");
return 3;
}
swap_rom((unsigned char*)ROM_ADDRESS, &imagetype, romlength);
memcpy(&ROM_HEADER, (uint32_t*)ROM_ADDRESS, sizeof(m64p_rom_header));
ROM_PARAMS.systemtype = rom_country_code_to_system_type(ROM_HEADER.Country_code);
printf("Name: %s\n", ROM_HEADER.Name);
printf("Rom size: %ld bytes (or %ld Mb or %ld Megabits)\n", romlength, romlength/1024/1024, romlength/1024/1024*8);
printf("ClockRate = %x\n", sl(ROM_HEADER.ClockRate));
printf("Version: %x\n", sl(ROM_HEADER.Release));
printf("PC = 0x%x\n\n", sl((unsigned int)ROM_HEADER.PC));
int x;
#if 1
for (x=0; x< romlength/4; x++)
*((uint32_t*)ROM_ADDRESS + x) = sl(*((uint32_t*)ROM_ADDRESS + x));
#endif
#if 0
for (x=0x40/4; x< 200; x++ )
{
mips_print((uint32_t)((uint32_t*)ROM_ADDRESS + x), *((uint32_t*)ROM_ADDRESS + x));
}
printf("----------------------------\n");
#endif
//Find all code where we don't know which registers are used
#if 0
printf("Unknown register usage on these instructions:\n\n");
for (x=0x40/4; x< romlength/4; x++ )
{
uint32_t temp;
if (ops_regs_input(((uint32_t*)ROM_ADDRESS)[x],&temp,&temp,&temp) == 2
|| ops_regs_output(((uint32_t*)ROM_ADDRESS)[x],&temp,&temp,&temp) == 2) mips_print((uint32_t*)ROM_ADDRESS + x, ((uint32_t*)ROM_ADDRESS)[x]);
}
printf("----------------------------\n");
#endif
GenerateCodeSegmentData(romlength);
#if 0
printf("MIPS Address Length Regs-cpu fpu sp used Next Block type 2=end,3=br\n");
nextCodeSeg = segmentData->StaticSegments;
int count =0;
while (nextCodeSeg != NULL && count < 20)
{
count++;
if (nextCodeSeg->MIPSReturnRegister)
{
printf("0x%08X 0x%08X %5d 0x%08X %08X %03X %2d r%d\n",
(uint32_t)nextCodeSeg->MIPScode,
(uint32_t)(nextCodeSeg->MIPScode+nextCodeSeg->MIPScodeLen),
nextCodeSeg->MIPScodeLen,
nextCodeSeg->MIPSRegistersUsed[0],
nextCodeSeg->MIPSRegistersUsed[1],
nextCodeSeg->MIPSRegistersUsed[2],
nextCodeSeg->MIPSRegistersUsedCount,
nextCodeSeg->MIPSReturnRegister);
}
else
{
printf("0x%08X 0x%08X %5d 0x%08X %08X %02X %2d 0x%08X %d\n",
(uint32_t)nextCodeSeg->MIPScode,
(uint32_t)(nextCodeSeg->MIPScode+nextCodeSeg->MIPScodeLen),
nextCodeSeg->MIPScodeLen,
nextCodeSeg->MIPSRegistersUsed[0],
nextCodeSeg->MIPSRegistersUsed[1],
nextCodeSeg->MIPSRegistersUsed[2],
nextCodeSeg->MIPSRegistersUsedCount,
(uint32_t)nextCodeSeg->MIPSnextInstructionIndex,
nextCodeSeg->Type);
}
nextCodeSeg = nextCodeSeg->next;
}
printf("----------------------------\n");
#endif
printf("%d code segments generated\n", segmentData.count);
printf("&segmentData.dbgCurrentSegment = 0x%08x\n", (uint32_t)&segmentData.dbgCurrentSegment);
// Instruction Counts for input ROM
#if 0
code_seg_t* nextCodeSeg;
uint32_t ins_count[sizeof_mips_op_t];
uint32_t ins_count_total=0;
memset(ins_count,0,sizeof(ins_count));
nextCodeSeg = segmentData.StaticSegments;
while (nextCodeSeg)
{
for (x=0; x < nextCodeSeg->MIPScodeLen; x++)
{
ins_count[STRIP(ops_type(*(nextCodeSeg->MIPScode + x)))] ++;
ins_count_total++;
}
nextCodeSeg = nextCodeSeg->next;
}
for (x=0; x < sizeof_mips_op_t; x++)
{
if (ins_count[x])
{
printf("%-9s %7d (%2.2f%%)\n",Instruction_ascii[x], ins_count[x], (double)ins_count[x] * 100 / ins_count_total);
}
}
printf("----------------------------\n");
#endif
r4300_reset_hard();
r4300_reset_soft();
printf("\nFinished processing ROM\n");
#endif
while (Debugger_start(&segmentData, NULL, NULL));
// Clean up Recompiler
freeCodeSegmentData();
munmap((uint32_t*)MMAP_BASE, MMAP_BASE_SIZE + romlength);
munmap((uint32_t*)MMAP_PIF_BOOT_ROM, 4096);
printf("\nEND\n");
return 0;
}
/*********************************************************************************************************
* emulation thread - runs the core
*/
m64p_error main_init(void)
{
size_t i;
unsigned int disable_extra_mem;
static int channels[] = { 0, 1, 2, 3 };
/* take the r4300 emulator mode from the config file at this point and cache it in a global variable */
r4300emu = ConfigGetParamInt(g_CoreConfig, "R4300Emulator");
/* set some other core parameters based on the config file values */
no_compiled_jump = ConfigGetParamBool(g_CoreConfig, "NoCompiledJump");
disable_extra_mem = ConfigGetParamInt(g_CoreConfig, "DisableExtraMem");
#if 0
count_per_op = ConfigGetParamInt(g_CoreConfig, "CountPerOp");
#endif
if (count_per_op <= 0)
count_per_op = 2;
/* do byte-swapping if it's not been done yet */
if (g_MemHasBeenBSwapped == 0)
{
swap_buffer(g_rom, 4, g_rom_size / 4);
g_MemHasBeenBSwapped = 1;
}
if (g_DDMemHasBeenBSwapped == 0)
{
swap_buffer(g_ddrom, 4, g_ddrom_size / 4);
g_DDMemHasBeenBSwapped = 1;
}
connect_all(&g_r4300, &g_dp, &g_sp,
&g_ai, &g_pi, &g_ri, &g_si, &g_vi, &g_dd,
g_rdram, (disable_extra_mem == 0) ? 0x800000 : 0x400000,
g_rom, g_rom_size, g_ddrom, g_ddrom_size, g_dd_disk, g_dd_disk_size);
init_memory();
// Attach rom to plugins
printf("Gfx RomOpen.\n");
if (!gfx.romOpen())
{
printf("Gfx RomOpen failed.\n");
return M64ERR_PLUGIN_FAIL;
}
printf("Input RomOpen.\n");
if (!input.romOpen())
{
printf("Input RomOpen failed.\n");
gfx.romClosed();
return M64ERR_PLUGIN_FAIL;
}
/* connect external time source to AF_RTC component */
g_si.pif.af_rtc.user_data = NULL;
g_si.pif.af_rtc.get_time = get_time_using_C_localtime;
/* connect external game controllers */
for(i = 0; i < GAME_CONTROLLERS_COUNT; ++i)
{
g_si.pif.controllers[i].user_data = &channels[i];
g_si.pif.controllers[i].is_connected = egcvip_is_connected;
g_si.pif.controllers[i].get_input = egcvip_get_input;
}
/* connect external rumblepaks */
for(i = 0; i < GAME_CONTROLLERS_COUNT; ++i)
{
g_si.pif.controllers[i].rumblepak.user_data = &channels[i];
g_si.pif.controllers[i].rumblepak.rumble = rvip_rumble;
}
/* connect saved_memory.mempacks to mempaks */
for(i = 0; i < GAME_CONTROLLERS_COUNT; ++i)
{
g_si.pif.controllers[i].mempak.user_data = NULL;
g_si.pif.controllers[i].mempak.save = dummy_save;
g_si.pif.controllers[i].mempak.data = &saved_memory.mempack[i][0];
}
/* connect saved_memory.eeprom to eeprom */
g_si.pif.eeprom.user_data = NULL;
g_si.pif.eeprom.save = dummy_save;
g_si.pif.eeprom.data = saved_memory.eeprom;
if (ROM_SETTINGS.savetype != EEPROM_16KB)
{
/* 4kbits EEPROM */
g_si.pif.eeprom.size = 0x200;
g_si.pif.eeprom.id = 0x8000;
}
else
{
/* 16kbits EEPROM */
g_si.pif.eeprom.size = 0x800;
g_si.pif.eeprom.id = 0xc000;
}
/* connect saved_memory.flashram to flashram */
g_pi.flashram.user_data = NULL;
g_pi.flashram.save = dummy_save;
g_pi.flashram.data = saved_memory.flashram;
/* connect saved_memory.sram to SRAM */
g_pi.sram.user_data = NULL;
g_pi.sram.save = dummy_save;
g_pi.sram.data = saved_memory.sram;
#ifdef DBG
if (ConfigGetParamBool(g_CoreConfig, "EnableDebugger"))
init_debugger();
#endif
g_EmulatorRunning = 1;
StateChanged(M64CORE_EMU_STATE, M64EMU_RUNNING);
/* call r4300 CPU core and run the game */
r4300_reset_hard();
r4300_reset_soft();
r4300_init();
return M64ERR_SUCCESS;
}
/*********************************************************************************************************
* emulation thread - runs the core
*/
m64p_error main_run(void)
{
VILimit = (float) GetVILimit();
VILimitMilliseconds = (double) 1000.0/VILimit;
/* take the r4300 emulator mode from the config file at this point and cache it in a global variable */
r4300emu = ConfigGetParamInt(g_CoreConfig, "R4300Emulator");
/* set some other core parameters based on the config file values */
savestates_set_autoinc_slot(ConfigGetParamBool(g_CoreConfig, "AutoStateSlotIncrement"));
savestates_select_slot(ConfigGetParamInt(g_CoreConfig, "CurrentStateSlot"));
no_compiled_jump = ConfigGetParamBool(g_CoreConfig, "NoCompiledJump");
/* set up the SDL key repeat and event filter to catch keyboard/joystick commands for the core */
event_initialize();
// initialize memory, and do byte-swapping if it's not been done yet
if (g_MemHasBeenBSwapped == 0)
{
init_memory(1);
g_MemHasBeenBSwapped = 1;
}
else
{
init_memory(0);
}
// Attach rom to plugins
if (!romOpen_gfx())
{
free_memory(); SDL_Quit(); return M64ERR_PLUGIN_FAIL;
}
if (!romOpen_audio())
{
romClosed_gfx(); free_memory(); SDL_Quit(); return M64ERR_PLUGIN_FAIL;
}
if (!romOpen_input())
{
romClosed_audio(); romClosed_gfx(); free_memory(); SDL_Quit(); return M64ERR_PLUGIN_FAIL;
}
if (ConfigGetParamBool(g_CoreConfig, "OnScreenDisplay"))
{
// init on-screen display
int width = 640, height = 480;
readScreen(NULL, &width, &height, 0); // read screen to get width and height
osd_init(width, height);
}
// setup rendering callback from video plugin to the core, for screenshots and On-Screen-Display
setRenderingCallback(video_plugin_render_callback);
#ifdef WITH_LIRC
lircStart();
#endif // WITH_LIRC
#ifdef DBG
if (ConfigGetParamBool(g_CoreConfig, "EnableDebugger"))
init_debugger();
#endif
/* Startup message on the OSD */
osd_new_message(OSD_MIDDLE_CENTER, "Mupen64Plus Started...");
g_EmulatorRunning = 1;
StateChanged(M64CORE_EMU_STATE, M64EMU_RUNNING);
/* call r4300 CPU core and run the game */
r4300_reset_hard();
r4300_reset_soft();
r4300_execute();
#ifdef WITH_LIRC
lircStop();
#endif // WITH_LIRC
#ifdef DBG
if (g_DebuggerActive)
destroy_debugger();
#endif
if (ConfigGetParamBool(g_CoreConfig, "OnScreenDisplay"))
{
osd_exit();
}
romClosed_RSP();
romClosed_input();
romClosed_audio();
romClosed_gfx();
free_memory();
// clean up
g_EmulatorRunning = 0;
StateChanged(M64CORE_EMU_STATE, M64EMU_STOPPED);
SDL_Quit();
return M64ERR_SUCCESS;
}
/*********************************************************************************************************
* emulation thread - runs the core
*/
m64p_error main_run(void)
{
DebugMessage(M64MSG_STATUS, "Main Run!");
VILimit = (float) GetVILimit();
VILimitMilliseconds = (double) 1000.0/VILimit;
/* take the r4300 emulator mode from the config file at this point and cache it in a global variable */
r4300emu = ConfigGetParamInt(g_CoreConfig, "R4300Emulator");
/* set some other core parameters based on the config file values */
savestates_set_autoinc_slot(ConfigGetParamBool(g_CoreConfig, "AutoStateSlotIncrement"));
savestates_select_slot(ConfigGetParamInt(g_CoreConfig, "CurrentStateSlot"));
no_compiled_jump = ConfigGetParamBool(g_CoreConfig, "NoCompiledJump");
/* set up the SDL key repeat and event filter to catch keyboard/joystick commands for the core */
event_initialize();
// initialize memory, and do byte-swapping if it's not been done yet
if (g_MemHasBeenBSwapped == 0)
{
init_memory(1);
g_MemHasBeenBSwapped = 1;
}
else
{
init_memory(0);
}
// Attach rom to plugins
if (!romOpen_gfx())
{
free_memory(); return M64ERR_PLUGIN_FAIL;
}
DebugMessage(M64MSG_STATUS, "Graphics Plugin Opened!");
if (!romOpen_audio())
{
romClosed_gfx(); free_memory(); return M64ERR_PLUGIN_FAIL;
}
DebugMessage(M64MSG_STATUS, "Audio Plugin Opened!");
if (!romOpen_input())
{
romClosed_audio(); romClosed_gfx(); free_memory(); return M64ERR_PLUGIN_FAIL;
}
DebugMessage(M64MSG_STATUS, "Input Plugin Opened!");
printf("Plugins opened!\n");fflush(stdout);
#ifdef WITH_LIRC
lircStart();
#endif // WITH_LIRC
#ifdef DBG
if (ConfigGetParamBool(g_CoreConfig, "EnableDebugger"))
init_debugger();
#endif
//PumpEvents();
g_EmulatorRunning = 1;
StateChanged(M64CORE_EMU_STATE, M64EMU_RUNNING);
DebugMessage(M64MSG_STATUS, "Starting to reset r4300!");fflush(stdout);
/* call r4300 CPU core and run the game */
r4300_reset_hard();
r4300_reset_soft();
DebugMessage(M64MSG_STATUS, "About to execute!");
fflush(stdout);
r4300_execute();
#ifdef WITH_LIRC
lircStop();
#endif // WITH_LIRC
#ifdef DBG
if (g_DebuggerActive)
destroy_debugger();
#endif
romClosed_RSP();
romClosed_input();
romClosed_audio();
romClosed_gfx();
free_memory();
// clean up
g_EmulatorRunning = 0;
StateChanged(M64CORE_EMU_STATE, M64EMU_STOPPED);
//PDL_Quit();
SDL_Quit();
return M64ERR_SUCCESS;
}
