dingusppc/main.cpp

255 lines
7.9 KiB
C++
Raw Normal View History

/*
DingusPPC - The Experimental PowerPC Macintosh emulator
2023-04-01 15:20:53 +00:00
Copyright (C) 2018-23 divingkatae and maximum
(theweirdo) spatium
(Contact divingkatae#1017 or powermax#2286 on Discord for more info)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
2020-05-12 18:55:45 +00:00
// The main runfile - main.cpp
// This is where the magic begins
2023-04-01 15:20:53 +00:00
#include <core/hostevents.h>
#include <core/timermanager.h>
#include <cpu/ppc/ppcemu.h>
#include <debugger/debugger.h>
#include <machines/machinebase.h>
2023-04-01 15:20:53 +00:00
#include <machines/machinefactory.h>
#include <utils/profiler.h>
#include <main.h>
2023-04-01 15:20:53 +00:00
2020-05-12 18:55:45 +00:00
#include <cinttypes>
2021-08-19 09:29:44 +00:00
#include <csignal>
2020-05-12 18:55:45 +00:00
#include <cstring>
#include <iostream>
2021-09-15 22:46:38 +00:00
#include <CLI11.hpp>
#include <loguru.hpp>
using namespace std;
2024-05-08 14:07:32 +00:00
static void sigint_handler(int signum) {
power_on = false;
power_off_reason = po_signal_interrupt;
2021-08-19 09:29:44 +00:00
}
2024-05-08 14:07:32 +00:00
static void sigabrt_handler(int signum) {
LOG_F(INFO, "Shutting down...");
delete gMachineObj.release();
cleanup();
}
static string appDescription = string(
2024-04-15 14:01:51 +00:00
"\nDingusPPC - Alpha 1 (5/10/2024) "
"\nWritten by divingkatae, maximumspatium, "
"\njoevt, mihaip, et. al. "
"\n(c) 2018-2024 The DingusPPC Dev Team. "
"\nThis is a build intended for testing. "
"\nUse at your own discretion. "
"\n"
);
2020-08-26 03:07:02 +00:00
void run_machine(std::string machine_str, std::string bootrom_path, uint32_t execution_mode, uint32_t profiling_interval_ms);
2020-05-12 18:55:45 +00:00
int main(int argc, char** argv) {
2020-08-22 18:05:08 +00:00
2023-06-20 05:36:27 +00:00
uint32_t execution_mode = interpreter;
2020-08-22 18:05:08 +00:00
CLI::App app(appDescription);
2020-09-20 21:25:29 +00:00
app.allow_windows_style_options(); /* we want Windows-style options */
app.allow_extras();
bool realtime_enabled, debugger_enabled;
string machine_str;
string bootrom_path("bootrom.bin");
app.add_flag("-r,--realtime", realtime_enabled,
"Run the emulator in real-time");
app.add_flag("-d,--debugger", debugger_enabled,
"Enter the built-in debugger");
app.add_option("-b,--bootrom", bootrom_path, "Specifies BootROM path")
->check(CLI::ExistingFile);
uint32_t profiling_interval_ms = 0;
#ifdef CPU_PROFILING
app.add_option("--profiling-interval-ms", profiling_interval_ms,
"Specifies periodic interval (in ms) at which to output CPU profiling information");
#endif
2020-09-20 21:25:29 +00:00
CLI::Option* machine_opt = app.add_option("-m,--machine",
machine_str, "Specify machine ID");
auto list_cmd = app.add_subcommand("list",
2020-09-20 21:25:29 +00:00
"Display available machine configurations and exit");
string sub_arg;
list_cmd->add_option("machines", sub_arg, "List supported machines");
list_cmd->add_option("properties", sub_arg, "List available properties");
2020-09-20 21:25:29 +00:00
CLI11_PARSE(app, argc, argv);
if (*list_cmd) {
2020-10-13 02:24:54 +00:00
if (sub_arg == "machines") {
MachineFactory::list_machines();
2020-10-13 02:24:54 +00:00
} else if (sub_arg == "properties") {
MachineFactory::list_properties();
2020-10-13 02:24:54 +00:00
} else {
cout << "Unknown list subcommand " << sub_arg << endl;
}
return 0;
}
2020-09-20 21:25:29 +00:00
if (debugger_enabled) {
if (realtime_enabled)
cout << "Both realtime and debugger enabled! Using debugger" << endl;
execution_mode = 1;
}
/* initialize logging */
loguru::g_preamble_date = false;
loguru::g_preamble_time = false;
loguru::g_preamble_thread = false;
if (!execution_mode) {
2020-09-20 21:25:29 +00:00
loguru::g_stderr_verbosity = loguru::Verbosity_OFF;
loguru::init(argc, argv);
loguru::add_file("dingusppc.log", loguru::Append, 0);
} else {
2021-08-03 14:01:32 +00:00
loguru::g_stderr_verbosity = loguru::Verbosity_INFO;
2020-09-20 21:25:29 +00:00
loguru::init(argc, argv);
}
if (*machine_opt) {
LOG_F(INFO, "Machine option was passed in: %s", machine_str.c_str());
} else {
machine_str = MachineFactory::machine_name_from_rom(bootrom_path);
2020-09-20 21:25:29 +00:00
if (machine_str.empty()) {
LOG_F(ERROR, "Could not autodetect machine");
return 1;
}
2020-10-04 16:58:21 +00:00
else {
LOG_F(INFO, "Machine was autodetected as: %s", machine_str.c_str());
2020-09-20 21:25:29 +00:00
}
}
/* handle overriding of machine settings from command line */
2020-09-20 21:25:29 +00:00
map<string, string> settings;
if (MachineFactory::get_machine_settings(machine_str, settings) < 0) {
return 1;
}
2020-09-20 21:25:29 +00:00
CLI::App sa;
sa.allow_extras();
for (auto& s : settings) {
sa.add_option("--" + s.first, s.second);
}
sa.parse(app.remaining_for_passthrough()); /* TODO: handle exceptions! */
MachineFactory::set_machine_settings(settings);
2020-09-20 21:25:29 +00:00
cout << "BootROM path: " << bootrom_path << endl;
cout << "Execution mode: " << execution_mode << endl;
if (!init()) {
LOG_F(ERROR, "Cannot initialize");
return 1;
}
2021-04-13 23:27:07 +00:00
// initialize global profiler object
gProfilerObj.reset(new Profiler());
// graceful handling of fatal errors
loguru::set_fatal_handler([](const loguru::Message& message) {
// Make sure the reason for the failure is visible (it may have been
// sent to the logfile only).
cerr << message.preamble << message.indentation << message.prefix << message.message << endl;
power_off_reason = po_enter_debugger;
enter_debugger();
// Ensure that NVRAM and other state is persisted before we terminate.
delete gMachineObj.release();
});
2021-08-19 09:29:44 +00:00
// redirect SIGINT to our own handler
signal(SIGINT, sigint_handler);
// redirect SIGABRT to our own handler
signal(SIGABRT, sigabrt_handler);
while (true) {
run_machine(machine_str, bootrom_path, execution_mode, profiling_interval_ms);
if (power_off_reason == po_restarting) {
LOG_F(INFO, "Restarting...");
power_on = true;
continue;
}
break;
}
cleanup();
return 0;
}
void run_machine(std::string machine_str, std::string bootrom_path, uint32_t execution_mode, uint32_t profiling_interval_ms) {
if (MachineFactory::create_machine_for_id(machine_str, bootrom_path) < 0) {
return;
}
2023-04-01 15:20:53 +00:00
// set up system wide event polling using
// default Macintosh polling rate of 11 ms
uint32_t event_timer = TimerManager::get_instance()->add_cyclic_timer(MSECS_TO_NSECS(11), [] {
2023-04-01 15:20:53 +00:00
EventManager::get_instance()->poll_events();
});
#ifdef CPU_PROFILING
uint32_t profiling_timer;
if (profiling_interval_ms > 0) {
profiling_timer = TimerManager::get_instance()->add_cyclic_timer(MSECS_TO_NSECS(profiling_interval_ms), [] {
gProfilerObj->print_profile("PPC_CPU");
});
}
#endif
2020-10-04 16:58:21 +00:00
switch (execution_mode) {
2023-06-20 05:36:27 +00:00
case interpreter:
power_off_reason = po_starting_up;
enter_debugger();
break;
2023-06-20 05:36:27 +00:00
case debugger:
power_off_reason = po_enter_debugger;
enter_debugger();
break;
default:
LOG_F(ERROR, "Invalid EXECUTION MODE");
return;
2020-09-20 21:25:29 +00:00
}
LOG_F(INFO, "Cleaning up...");
TimerManager::get_instance()->cancel_timer(event_timer);
#ifdef CPU_PROFILING
if (profiling_interval_ms > 0) {
TimerManager::get_instance()->cancel_timer(profiling_timer);
}
#endif
EventManager::get_instance()->disconnect_handlers();
delete gMachineObj.release();
}