@patleeman/pi-boy 0.1.0

package/mgba-bridge/vendor/mgba/src/debugger/stack-trace.c

@@ -0,0 +1,133 @@
+/* Copyright (c) 2013-2020 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include <mgba/internal/debugger/stack-trace.h>
+#include <mgba/internal/debugger/symbols.h>
+
+#include <mgba/core/core.h>
+
+#define CHECK_LENGTH() \
+	if (written >= *length) { \
+		*length = written; \
+		return; \
+	}
+
+DEFINE_VECTOR(mStackFrames, struct mStackFrame);
+
+void mStackTraceInit(struct mStackTrace* stack, size_t registersSize) {
+	mStackFramesInit(&stack->stack, 0);
+	stack->registersSize = registersSize;
+}
+
+void mStackTraceDeinit(struct mStackTrace* stack) {
+	mStackTraceClear(stack);
+	mStackFramesDeinit(&stack->stack);
+}
+
+void mStackTraceClear(struct mStackTrace* stack) {
+	ssize_t i = mStackTraceGetDepth(stack) - 1;
+	while (i >= 0) {
+		free(mStackTraceGetFrame(stack, i)->regs);
+		--i;
+	}
+	mStackFramesClear(&stack->stack);
+}
+
+size_t mStackTraceGetDepth(struct mStackTrace* stack) {
+	return mStackFramesSize(&stack->stack);
+}
+
+struct mStackFrame* mStackTracePush(struct mStackTrace* stack, uint32_t pc, uint32_t destAddress, uint32_t sp, void* regs) {
+	struct mStackFrame* frame = mStackFramesAppend(&stack->stack);
+	frame->callSegment = -1;
+	frame->callAddress = pc;
+	frame->entrySegment = -1;
+	frame->entryAddress = destAddress;
+	frame->frameBaseSegment = -1;
+	frame->frameBaseAddress = sp;
+	frame->regs = malloc(stack->registersSize);
+	frame->finished = false;
+	frame->breakWhenFinished = false;
+	frame->interrupt = false;
+	memcpy(frame->regs, regs, stack->registersSize);
+	return frame;
+}
+
+struct mStackFrame* mStackTracePushSegmented(struct mStackTrace* stack, int pcSegment, uint32_t pc, int destSegment, uint32_t destAddress, int spSegment, uint32_t sp, void* regs) {
+	struct mStackFrame* frame = mStackTracePush(stack, pc, destAddress, sp, regs);
+	frame->callSegment = pcSegment;
+	frame->entrySegment = destSegment;
+	frame->frameBaseSegment = spSegment;
+	return frame;
+}
+
+struct mStackFrame* mStackTraceGetFrame(struct mStackTrace* stack, uint32_t frame) {
+	size_t depth = mStackTraceGetDepth(stack);
+	if (frame >= depth) {
+		return NULL;
+	}
+	return mStackFramesGetPointer(&stack->stack, depth - frame - 1);
+}
+
+void mStackTraceFormatFrame(struct mStackTrace* stack, struct mDebuggerSymbols* st, uint32_t frame, char* out, size_t* length) {
+	struct mStackFrame* stackFrame = mStackTraceGetFrame(stack, frame);
+	struct mStackFrame* prevFrame = mStackTraceGetFrame(stack, frame + 1);
+	size_t written = snprintf(out, *length, "#%d  ", frame);
+	CHECK_LENGTH();
+	if (!stackFrame) {
+		written += snprintf(out + written, *length - written, "(no stack frame available)\n");
+		*length = written;
+		return;
+	}
+	const char* functionName = mDebuggerSymbolReverseLookup(st, stackFrame->entryAddress, stackFrame->entrySegment);
+	if (functionName) {
+		written += snprintf(out + written, *length - written, "%s ", functionName);
+	} else if (stackFrame->entrySegment >= 0) {
+		written += snprintf(out + written, *length - written, "0x%02X:%08X ", stackFrame->entrySegment, stackFrame->entryAddress);
+	} else {
+		written += snprintf(out + written, *length - written, "0x%08X ", stackFrame->entryAddress);
+	}
+	CHECK_LENGTH();
+	if (stack->formatRegisters) {
+		written += snprintf(out + written, *length - written, "(");
+		CHECK_LENGTH();
+		char buffer[1024];
+		size_t formattedSize = sizeof(buffer) - 2;
+		stack->formatRegisters(stackFrame, buffer, &formattedSize);
+		written += snprintf(out + written, *length - written, "%s)\n    ", buffer);
+		CHECK_LENGTH();
+	}
+	if (stackFrame->callSegment >= 0) {
+		written += snprintf(out + written, *length - written, "at 0x%02X:%08X", stackFrame->callSegment, stackFrame->callAddress);
+	} else {
+		written += snprintf(out + written, *length - written, "at 0x%08X", stackFrame->callAddress);
+	}
+	CHECK_LENGTH();
+	if (prevFrame) {
+		int32_t offset = stackFrame->callAddress - prevFrame->entryAddress;
+		if (offset >= 0) {
+			functionName = mDebuggerSymbolReverseLookup(st, prevFrame->entryAddress, prevFrame->entrySegment);
+			if (functionName) {
+				written += snprintf(out + written, *length - written, " [%s+%d]", functionName, offset);
+			} else if (prevFrame->entrySegment >= 0) {
+				written += snprintf(out + written, *length - written, " [0x%02X:%08X+%d]", prevFrame->entrySegment, prevFrame->entryAddress, offset);
+			} else {
+				written += snprintf(out + written, *length - written, " [0x%08X+%d]", prevFrame->entryAddress, offset);
+			}
+		}
+	}
+	CHECK_LENGTH();
+	written += snprintf(out + written, *length - written, "\n");
+	*length = written;
+}
+
+void mStackTracePop(struct mStackTrace* stack) {
+	size_t depth = mStackTraceGetDepth(stack);
+	if (depth > 0) {
+		struct mStackFrame* frame = mStackFramesGetPointer(&stack->stack, depth - 1);
+		free(frame->regs);
+		mStackFramesResize(&stack->stack, -1);
+	}
+}

package/mgba-bridge/vendor/mgba/src/debugger/symbols.c

@@ -0,0 +1,109 @@
+/* Copyright (c) 2013-2017 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include <mgba/internal/debugger/symbols.h>
+
+#include <mgba-util/string.h>
+#include <mgba-util/table.h>
+#include <mgba-util/hash.h>
+#include <mgba-util/vfs.h>
+
+struct mDebuggerSymbol {
+	int32_t value;
+	int segment;
+};
+
+struct mDebuggerSymbols {
+	struct Table names;
+	struct Table reverse;
+};
+
+struct mDebuggerSymbols* mDebuggerSymbolTableCreate(void) {
+	struct mDebuggerSymbols* st = malloc(sizeof(*st));
+	HashTableInit(&st->names, 0, free);
+	HashTableInit(&st->reverse, 0, free);
+	return st;
+}
+
+void mDebuggerSymbolTableDestroy(struct mDebuggerSymbols* st) {
+	HashTableDeinit(&st->names);
+	HashTableDeinit(&st->reverse);
+	free(st);
+}
+
+bool mDebuggerSymbolLookup(const struct mDebuggerSymbols* st, const char* name, int32_t* value, int* segment) {
+	struct mDebuggerSymbol* sym = HashTableLookup(&st->names, name);
+	if (!sym) {
+		return false;
+	}
+	*value = sym->value;
+	*segment = sym->segment;
+	return true;
+}
+
+const char* mDebuggerSymbolReverseLookup(const struct mDebuggerSymbols* st, int32_t value, int segment) {
+	struct mDebuggerSymbol sym = { value, segment };
+	return HashTableLookupBinary(&st->reverse, &sym, sizeof(sym));
+}
+
+void mDebuggerSymbolAdd(struct mDebuggerSymbols* st, const char* name, int32_t value, int segment) {
+	struct mDebuggerSymbol* sym = malloc(sizeof(*sym));
+	sym->value = value;
+	sym->segment = segment;
+	HashTableInsert(&st->names, name, sym);
+	HashTableInsertBinary(&st->reverse, sym, sizeof(*sym), strdup(name));
+}
+
+void mDebuggerSymbolRemove(struct mDebuggerSymbols* st, const char* name) {
+	struct mDebuggerSymbol* sym = HashTableLookup(&st->names, name);
+	if (sym) {
+		HashTableRemoveBinary(&st->reverse, sym, sizeof(*sym));
+		HashTableRemove(&st->names, name);
+	}
+}
+
+void mDebuggerLoadARMIPSSymbols(struct mDebuggerSymbols* st, struct VFile* vf) {
+	char line[512];
+
+	while (true) {
+		ssize_t bytesRead = vf->readline(vf, line, sizeof(line));
+		if (bytesRead <= 0) {
+			break;
+		}
+		if (line[bytesRead - 1] == '\n') {
+			line[bytesRead - 1] = '\0';
+		}
+		uint32_t address = 0;
+		const char* buf = line;
+		buf = hex32(buf, &address);
+		if (!buf) {
+			continue;
+		}
+		bytesRead -= 8;
+
+		while (isspace((int) buf[0]) && bytesRead > 0) {
+			--bytesRead;
+			++buf;
+		}
+
+		if (!bytesRead) {
+			continue;
+		}
+
+		if (buf[0] == '.') {
+			// Directives are not handled yet
+			continue;
+		}
+
+		char* buf2 = strchr(buf, ',');
+
+		if (buf2 != NULL) {
+			// Commas separate names from function sizes
+			*buf2 = '\0';
+		}
+
+		mDebuggerSymbolAdd(st, buf, address, -1);
+	}
+}

package/mgba-bridge/vendor/mgba/src/feature/CMakeLists.txt

@@ -0,0 +1,24 @@
+include(ExportDirectory)
+set(SOURCE_FILES
+	commandline.c
+	proxy-backend.c
+	thread-proxy.c
+	video-backend.c
+	video-logger.c)
+
+if(ENABLE_VFS)
+	list(APPEND SOURCE_FILES
+		updater.c)
+endif()
+
+set(GUI_FILES
+	gui/cheats.c
+	gui/gui-config.c
+	gui/gui-runner.c
+	gui/remap.c)
+
+source_group("Extra features" FILES ${SOURCE_FILES})
+source_group("Extra GUI source" FILES ${GUI_FILES})
+
+export_directory(EXTRA SOURCE_FILES)
+export_directory(EXTRA_GUI GUI_FILES)

package/mgba-bridge/vendor/mgba/src/feature/commandline.c

@@ -0,0 +1,404 @@
+/* Copyright (c) 2013-2015 Jeffrey Pfau
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include <mgba/feature/commandline.h>
+
+#include <mgba/core/cheats.h>
+#include <mgba/core/config.h>
+#include <mgba/core/core.h>
+#include <mgba/core/version.h>
+#include <mgba-util/string.h>
+#include <mgba-util/vfs.h>
+
+#ifdef ENABLE_GDB_STUB
+#include <mgba/internal/debugger/gdb-stub.h>
+#endif
+#ifdef USE_EDITLINE
+#include <mgba/internal/debugger/cli-el-backend.h>
+#endif
+
+#include <fcntl.h>
+#ifdef _MSC_VER
+#include <mgba-util/platform/windows/getopt.h>
+#else
+#include <getopt.h>
+#endif
+
+#define GRAPHICS_OPTIONS "12345678f"
+#define GRAPHICS_USAGE \
+	"Graphics options:\n" \
+	"  -1, -2, -3, -4, -5, -6, -7, -8  Scale viewport by 1-8 times\n" \
+	"  -f, --fullscreen                Start full-screen\n" \
+	"  --scale X                       Scale viewport by X times"
+
+static const struct option _options[] = {
+	{ "bios",      required_argument, 0, 'b' },
+	{ "cheats",    required_argument, 0, 'c' },
+	{ "frameskip", required_argument, 0, 's' },
+#ifdef USE_EDITLINE
+	{ "debug",     no_argument, 0, 'd' },
+#endif
+#ifdef ENABLE_GDB_STUB
+	{ "gdb",       no_argument, 0, 'g' },
+#endif
+	{ "help",      no_argument, 0, 'h' },
+	{ "log-level", required_argument, 0, 'l' },
+	{ "savestate", required_argument, 0, 't' },
+	{ "patch",     required_argument, 0, 'p' },
+	{ "version",   no_argument, 0, '\0' },
+	{ 0, 0, 0, 0 }
+};
+
+static const struct mOption _graphicsLongOpts[] = {
+	{ "fullscreen", false, 'f' },
+	{ "scale", true, '\0' },
+	{ 0, 0, 0 }
+};
+
+static bool _parseGraphicsArg(struct mSubParser* parser, int option, const char* arg);
+static bool _parseLongGraphicsArg(struct mSubParser* parser, const char* option, const char* arg);
+static void _applyGraphicsArgs(struct mSubParser* parser, struct mCoreConfig* config);
+
+static void _tableInsert(struct Table* table, const char* pair) {
+	char* eq = strchr(pair, '=');
+	if (eq) {
+		char option[128] = "";
+		strncpy(option, pair, eq - pair);
+		option[sizeof(option) - 1] = '\0';
+		HashTableInsert(table, option, strdup(&eq[1]));
+	} else {
+		HashTableInsert(table, pair, strdup("1"));
+	}
+}
+
+static void _tableApply(const char* key, void* value, void* user) {
+	struct mCoreConfig* config = user;
+	mCoreConfigSetOverrideValue(config, key, value);
+}
+
+bool mArgumentsParse(struct mArguments* args, int argc, char* const* argv, struct mSubParser* subparsers, int nSubparsers) {
+	int ch;
+	char options[128] =
+		"b:c:C:hl:p:s:t:"
+#ifdef USE_EDITLINE
+		"d"
+#endif
+#ifdef ENABLE_GDB_STUB
+		"g"
+#endif
+	;
+
+	struct option longOptions[128] = {0};
+	memcpy(longOptions, _options, sizeof(_options));
+
+	memset(args, 0, sizeof(*args));
+	args->frameskip = -1;
+	args->logLevel = INT_MIN;
+	HashTableInit(&args->configOverrides, 0, free);
+	int lastLongOpt;
+
+	int i, j;
+	for (i = 0; _options[i].name; ++i); // Seek to end
+	lastLongOpt = i;
+
+	for (i = 0; i < nSubparsers; ++i) {
+		if (subparsers[i].extraOptions) {
+			strncat(options, subparsers[i].extraOptions, sizeof(options) - strlen(options) - 1);
+		}
+		if (subparsers[i].longOptions) {
+			for (j = 0; subparsers[i].longOptions[j].name; ++j) {
+				longOptions[lastLongOpt].name = subparsers[i].longOptions[j].name;
+				longOptions[lastLongOpt].has_arg = subparsers[i].longOptions[j].arg ? required_argument : no_argument;
+				longOptions[lastLongOpt].flag = NULL;
+				longOptions[lastLongOpt].val = subparsers[i].longOptions[j].shortEquiv;
+				++lastLongOpt;
+			}
+		}
+	}
+	bool ok = false;
+	int index = 0;
+	while ((ch = getopt_long(argc, argv, options, longOptions, &index)) != -1) {
+		const struct option* opt = &longOptions[index];
+		switch (ch) {
+		case '\0':
+			if (strcmp(opt->name, "version") == 0) {
+				args->showVersion = true;
+			} else {
+				for (i = 0; i < nSubparsers; ++i) {
+					if (subparsers[i].parseLong) {
+						ok = subparsers[i].parseLong(&subparsers[i], opt->name, optarg) || ok;
+					}
+				}
+				if (!ok) {
+					return false;
+				}
+			}
+			break;
+		case 'b':
+			args->bios = strdup(optarg);
+			break;
+		case 'c':
+			args->cheatsFile = strdup(optarg);
+			break;
+		case 'C':
+			_tableInsert(&args->configOverrides, optarg);
+			break;
+#ifdef USE_EDITLINE
+		case 'd':
+			args->debugAtStart = true;
+			args->debugCli = true;
+			break;
+#endif
+#ifdef ENABLE_GDB_STUB
+		case 'g':
+			args->debugAtStart = true;
+			args->debugGdb = true;
+			break;
+#endif
+		case 'h':
+			args->showHelp = true;
+			break;
+		case 'l':
+			args->logLevel = atoi(optarg);
+			break;
+		case 'p':
+			args->patch = strdup(optarg);
+			break;
+		case 's':
+			args->frameskip = atoi(optarg);
+			break;
+		case 't':
+			args->savestate = strdup(optarg);
+			break;
+		default:
+			for (i = 0; i < nSubparsers; ++i) {
+				if (subparsers[i].parse) {
+					ok = subparsers[i].parse(&subparsers[i], ch, optarg) || ok;
+				}
+			}
+			if (!ok) {
+				return false;
+			}
+			break;
+		}
+	}
+	argc -= optind;
+	argv += optind;
+	if (argc > 1) {
+		for (j = 0; j < argc; ++j) {
+			bool handled = false;
+			for (i = 0; i < nSubparsers; ++i) {
+				if (!subparsers[i].handleExtraArg) {
+					continue;
+				}
+				handled = subparsers[i].handleExtraArg(&subparsers[i], argv[j]);
+				if (handled) {
+					break;
+				}
+			}
+			if (!handled) {
+				return false;
+			}
+		}
+	} else if (argc == 1) {
+		args->fname = strdup(argv[0]);
+	} else {
+		args->fname = NULL;
+	}
+	return true;
+}
+
+void mArgumentsApply(const struct mArguments* args, struct mSubParser* subparsers, int nSubparsers, struct mCoreConfig* config) {
+	if (args->frameskip >= 0) {
+		mCoreConfigSetOverrideIntValue(config, "frameskip", args->frameskip);
+	}
+	if (args->logLevel > INT_MIN) {
+		mCoreConfigSetOverrideIntValue(config, "logLevel", args->logLevel);
+	}
+	if (args->bios) {
+		mCoreConfigSetOverrideValue(config, "bios", args->bios);
+		mCoreConfigSetOverrideIntValue(config, "useBios", true);
+	}
+	HashTableEnumerate(&args->configOverrides, _tableApply, config);
+	int i;
+	for (i = 0; i < nSubparsers; ++i) {
+		if (subparsers[i].apply) {
+			subparsers[i].apply(&subparsers[i], config);
+		}
+	}
+}
+
+bool mArgumentsApplyDebugger(const struct mArguments* args, struct mCore* core, struct mDebugger* debugger) {
+	UNUSED(args);
+	UNUSED(core);
+	UNUSED(debugger);
+	bool hasDebugger = false;
+
+#ifdef USE_EDITLINE
+	if (args->debugCli) {
+		struct mDebuggerModule* module = mDebuggerCreateModule(DEBUGGER_CLI, core);
+		if (module) {
+			struct CLIDebugger* cliDebugger = (struct CLIDebugger*) module;
+			CLIDebuggerAttachBackend(cliDebugger, CLIDebuggerEditLineBackendCreate());
+			mDebuggerAttachModule(debugger, module);
+			hasDebugger = true;
+		}
+	}
+#endif
+
+#ifdef ENABLE_GDB_STUB
+	if (args->debugGdb) {
+		struct mDebuggerModule* module = mDebuggerCreateModule(DEBUGGER_GDB, core);
+		if (module) {
+			mDebuggerAttachModule(debugger, module);
+			hasDebugger = true;
+		}
+	}
+#endif
+
+	return hasDebugger;
+}
+
+void mArgumentsApplyFileLoads(const struct mArguments* args, struct mCore* core) {
+#ifdef ENABLE_VFS
+	if (args->patch) {
+		struct VFile* patch = VFileOpen(args->patch, O_RDONLY);
+		if (patch) {
+			core->loadPatch(core, patch);
+			patch->close(patch);
+		}
+	} else {
+		mCoreAutoloadPatch(core);
+	}
+
+	struct mCheatDevice* device = NULL;
+	if (args->cheatsFile && (device = core->cheatDevice(core))) {
+		struct VFile* vf = VFileOpen(args->cheatsFile, O_RDONLY);
+		if (vf) {
+			mCheatDeviceClear(device);
+			mCheatParseFile(device, vf);
+			vf->close(vf);
+		}
+	} else {
+		mCoreAutoloadCheats(core);
+	}
+#else
+	UNUSED(args);
+	UNUSED(core);
+#endif
+}
+
+void mArgumentsDeinit(struct mArguments* args) {
+	free(args->fname);
+	args->fname = 0;
+
+	free(args->patch);
+	args->patch = 0;
+
+	free(args->savestate);
+	args->savestate = 0;
+
+	free(args->cheatsFile);
+	args->cheatsFile = 0;
+
+	free(args->bios);
+	args->bios = 0;
+
+	HashTableDeinit(&args->configOverrides);
+}
+
+void mSubParserGraphicsInit(struct mSubParser* parser, struct mGraphicsOpts* opts) {
+	parser->usage = GRAPHICS_USAGE;
+	parser->opts = opts;
+	parser->parse = _parseGraphicsArg;
+	parser->parseLong = _parseLongGraphicsArg;
+	parser->apply = _applyGraphicsArgs;
+	parser->extraOptions = GRAPHICS_OPTIONS;
+	parser->longOptions = _graphicsLongOpts;
+	parser->handleExtraArg = NULL;
+	opts->multiplier = 0;
+	opts->fullscreen = false;
+}
+
+bool _parseGraphicsArg(struct mSubParser* parser, int option, const char* arg) {
+	UNUSED(arg);
+	struct mGraphicsOpts* graphicsOpts = parser->opts;
+	switch (option) {
+	case 'f':
+		graphicsOpts->fullscreen = true;
+		return true;
+	case '1':
+	case '2':
+	case '3':
+	case '4':
+	case '5':
+	case '6':
+	case '7':
+	case '8':
+		if (graphicsOpts->multiplier) {
+			return false;
+		}
+		graphicsOpts->multiplier = option - '0';
+		return true;
+	default:
+		return false;
+	}
+}
+
+bool _parseLongGraphicsArg(struct mSubParser* parser, const char* option, const char* arg) {
+	struct mGraphicsOpts* graphicsOpts = parser->opts;
+	if (strcmp(option, "scale") == 0) {
+		if (graphicsOpts->multiplier) {
+			return false;
+		}
+		graphicsOpts->multiplier = atoi(arg);
+		return graphicsOpts->multiplier != 0;
+	}
+	return false;
+}
+
+void _applyGraphicsArgs(struct mSubParser* parser, struct mCoreConfig* config) {
+	struct mGraphicsOpts* graphicsOpts = parser->opts;
+	if (graphicsOpts->fullscreen) {
+		mCoreConfigSetOverrideIntValue(config, "fullscreen", graphicsOpts->fullscreen);
+	}
+}
+
+void usage(const char* arg0, const char* prologue, const char* epilogue, const struct mSubParser* subparsers, int nSubparsers) {
+	printf("usage: %s [option ...] file\n", arg0);
+	if (prologue) {
+		puts(prologue);
+	}
+	puts("\nGeneric options:\n"
+	     "  -b, --bios FILE            GBA BIOS file to use\n"
+	     "  -c, --cheats FILE          Apply cheat codes from a file\n"
+	     "  -C, --config OPTION=VALUE  Override config value\n"
+#ifdef USE_EDITLINE
+	     "  -d, --debug                Use command-line debugger\n"
+#endif
+#ifdef ENABLE_GDB_STUB
+	     "  -g, --gdb                  Start GDB session (default port 2345)\n"
+#endif
+	     "  -l, --log-level N          Log level mask\n"
+	     "  -t, --savestate FILE       Load savestate when starting\n"
+	     "  -p, --patch FILE           Apply a specified patch file when running\n"
+	     "  -s, --frameskip N          Skip every N frames\n"
+	     "  --version                  Print version and exit"
+	);
+	int i;
+	for (i = 0; i < nSubparsers; ++i) {
+		if (subparsers[i].usage) {
+			puts("");
+			puts(subparsers[i].usage);
+		}
+	}
+	if (epilogue) {
+		puts(epilogue);
+	}
+}
+
+void version(const char* arg0) {
+	printf("%s %s (%s)\n", arg0, projectVersion, gitCommit);
+}