Update to mGBA 0.8.4

Info.plist

@@ -17,7 +17,7 @@
 	<key>CFBundleSignature</key>
 	<string>????</string>
 	<key>CFBundleVersion</key>
-	<string>0.8.3</string>
+	<string>0.8.4</string>
 	<key>NSPrincipalClass</key>
 	<string>OEGameCoreController</string>
 	<key>OEGameCoreClass</key>

include/mgba-util/common.h

@@ -134,31 +134,32 @@ typedef intptr_t ssize_t;
 #define LOAD_32BE(DEST, ADDR, ARR) DEST = *(uint32_t*) ((uintptr_t) (ARR) + (size_t) (ADDR))
 #if defined(__PPC__) || defined(__POWERPC__)
 #define LOAD_32LE(DEST, ADDR, ARR) { \
-	uint32_t _addr = (ADDR); \
+	size_t _addr = (ADDR); \
 	const void* _ptr = (ARR); \
 	__asm__("lwbrx %0, %1, %2" : "=r"(DEST) : "b"(_ptr), "r"(_addr)); \
 }
 
 #define LOAD_16LE(DEST, ADDR, ARR) { \
-	uint32_t _addr = (ADDR); \
+	size_t _addr = (ADDR); \
 	const void* _ptr = (ARR); \
 	__asm__("lhbrx %0, %1, %2" : "=r"(DEST) : "b"(_ptr), "r"(_addr)); \
 }
 
 #define STORE_32LE(SRC, ADDR, ARR) { \
-	uint32_t _addr = (ADDR); \
+	size_t _addr = (ADDR); \
 	void* _ptr = (ARR); \
 	__asm__("stwbrx %0, %1, %2" : : "r"(SRC), "b"(_ptr), "r"(_addr) : "memory"); \
 }
 
 #define STORE_16LE(SRC, ADDR, ARR) { \
-	uint32_t _addr = (ADDR); \
+	size_t _addr = (ADDR); \
 	void* _ptr = (ARR); \
 	__asm__("sthbrx %0, %1, %2" : : "r"(SRC), "b"(_ptr), "r"(_addr) : "memory"); \
 }
 
+#ifndef _ARCH_PWR7
 #define LOAD_64LE(DEST, ADDR, ARR) { \
-	uint32_t _addr = (ADDR); \
+	size_t _addr = (ADDR); \
 	union { \
 		struct { \
 			uint32_t hi; \
@@ -175,7 +176,7 @@ typedef intptr_t ssize_t;
 }
 
 #define STORE_64LE(SRC, ADDR, ARR) { \
-	uint32_t _addr = (ADDR); \
+	size_t _addr = (ADDR); \
 	union { \
 		struct { \
 			uint32_t hi; \
@@ -189,6 +190,19 @@ typedef intptr_t ssize_t;
 		"stwbrx %1, %2, %4 \n" \
 		: : "r"(bswap.hi), "r"(bswap.lo), "b"(_ptr), "r"(_addr), "r"(_addr + 4) : "memory"); \
 }
+#else
+#define LOAD_64LE(DEST, ADDR, ARR) { \
+	size_t _addr = (ADDR); \
+	const void* _ptr = (ARR); \
+	__asm__("ldbrx %0, %1, %2" : "=r"(DEST) : "b"(_ptr), "r"(_addr)); \
+}
+
+#define STORE_64LE(SRC, ADDR, ARR) { \
+	size_t _addr = (ADDR); \
+	void* _ptr = (ARR); \
+	__asm__("stdbrx %0, %1, %2" : : "r"(SRC), "b"(_ptr), "r"(_addr) : "memory"); \
+}
+#endif
 
 #elif defined(__llvm__) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
 #define LOAD_64LE(DEST, ADDR, ARR) DEST = __builtin_bswap64(((uint64_t*) ARR)[(ADDR) >> 3])

include/mgba-util/socket.h

@@ -20,15 +20,21 @@ CXX_GUARD_START
 #define SOCKET_FAILED(s) ((s) == INVALID_SOCKET)
 typedef SOCKET Socket;
 #else
+#ifdef GEKKO
+#include <network.h>
+#else
 #include <arpa/inet.h>
-#include <errno.h>
-#include <fcntl.h>
 #include <netinet/in.h>
 #include <netinet/tcp.h>
-#include <sys/select.h>
 #include <sys/socket.h>
+#endif
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/select.h>
 
+#ifndef GEKKO
 #define INVALID_SOCKET (-1)
+#endif
 #define SOCKET_FAILED(s) ((s) < 0)
 typedef int Socket;
 #endif
@@ -70,6 +76,8 @@ static inline void SocketSubsystemInit() {
 	}
 #elif defined(__SWITCH__)
 	socketInitializeDefault();
+#elif defined(GEKKO)
+	net_init();
 #endif
 }
 
@@ -82,6 +90,8 @@ static inline void SocketSubsystemDeinit() {
 	SOCUBuffer = NULL;
 #elif defined(__SWITCH__)
 	socketExit();
+#elif defined(GEKKO)
+	net_deinit();
 #endif
 }
 
@@ -104,6 +114,8 @@ static inline bool SocketWouldBlock() {
 static inline ssize_t SocketSend(Socket socket, const void* buffer, size_t size) {
 #ifdef _WIN32
 	return send(socket, (const char*) buffer, size, 0);
+#elif defined(GEKKO)
+	return net_write(socket, buffer, size);
 #else
 	return write(socket, buffer, size);
 #endif
@@ -112,6 +124,8 @@ static inline ssize_t SocketSend(Socket socket, const void* buffer, size_t size)
 static inline ssize_t SocketRecv(Socket socket, void* buffer, size_t size) {
 #if defined(_WIN32) || defined(__SWITCH__)
 	return recv(socket, (char*) buffer, size, 0);
+#elif defined(GEKKO)
+	return net_read(socket, buffer, size);
 #else
 	return read(socket, buffer, size);
 #endif
@@ -120,13 +134,19 @@ static inline ssize_t SocketRecv(Socket socket, void* buffer, size_t size) {
 static inline int SocketClose(Socket socket) {
 #ifdef _WIN32
 	return closesocket(socket) == 0;
+#elif defined(GEKKO)
+	return net_close(socket) >= 0;
 #else
 	return close(socket) >= 0;
 #endif
 }
 
 static inline Socket SocketOpenTCP(int port, const struct Address* bindAddress) {
+#ifdef GEKKO
+	Socket sock = net_socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
+#else
 	Socket sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
+#endif
 	if (SOCKET_FAILED(sock)) {
 		return sock;
 	}
@@ -142,15 +162,23 @@ static inline Socket SocketOpenTCP(int port, const struct Address* bindAddress)
 #else
 		bindInfo.sin_addr.s_addr = gethostid();
 #endif
+#ifdef GEKKO
+		err = net_bind(sock, (struct sockaddr*) &bindInfo, sizeof(bindInfo));
+#else
 		err = bind(sock, (const struct sockaddr*) &bindInfo, sizeof(bindInfo));
+#endif
 	} else if (bindAddress->version == IPV4) {
 		struct sockaddr_in bindInfo;
 		memset(&bindInfo, 0, sizeof(bindInfo));
 		bindInfo.sin_family = AF_INET;
 		bindInfo.sin_port = htons(port);
 		bindInfo.sin_addr.s_addr = htonl(bindAddress->ipv4);
+#ifdef GEKKO
+		err = net_bind(sock, (struct sockaddr*) &bindInfo, sizeof(bindInfo));
+#else
 		err = bind(sock, (const struct sockaddr*) &bindInfo, sizeof(bindInfo));
-#ifndef _3DS
+#endif
+#if !defined(_3DS) && !defined(GEKKO)
 	} else {
 		struct sockaddr_in6 bindInfo;
 		memset(&bindInfo, 0, sizeof(bindInfo));
@@ -168,7 +196,11 @@ static inline Socket SocketOpenTCP(int port, const struct Address* bindAddress)
 }
 
 static inline Socket SocketConnectTCP(int port, const struct Address* destinationAddress) {
+#ifdef GEKKO
+	Socket sock = net_socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
+#else
 	Socket sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
+#endif
 	if (SOCKET_FAILED(sock)) {
 		return sock;
 	}
@@ -179,15 +211,23 @@ static inline Socket SocketConnectTCP(int port, const struct Address* destinatio
 		memset(&bindInfo, 0, sizeof(bindInfo));
 		bindInfo.sin_family = AF_INET;
 		bindInfo.sin_port = htons(port);
+#ifdef GEKKO
+		err = net_connect(sock, (struct sockaddr*) &bindInfo, sizeof(bindInfo));
+#else
 		err = connect(sock, (const struct sockaddr*) &bindInfo, sizeof(bindInfo));
+#endif
 	} else if (destinationAddress->version == IPV4) {
 		struct sockaddr_in bindInfo;
 		memset(&bindInfo, 0, sizeof(bindInfo));
 		bindInfo.sin_family = AF_INET;
 		bindInfo.sin_port = htons(port);
 		bindInfo.sin_addr.s_addr = htonl(destinationAddress->ipv4);
+#ifdef GEKKO
+		err = net_connect(sock, (struct sockaddr*) &bindInfo, sizeof(bindInfo));
+#else
 		err = connect(sock, (const struct sockaddr*) &bindInfo, sizeof(bindInfo));
-#ifndef _3DS
+#endif
+#if !defined(_3DS) && !defined(GEKKO)
 	} else {
 		struct sockaddr_in6 bindInfo;
 		memset(&bindInfo, 0, sizeof(bindInfo));
@@ -206,21 +246,36 @@ static inline Socket SocketConnectTCP(int port, const struct Address* destinatio
 }
 
 static inline Socket SocketListen(Socket socket, int queueLength) {
+#ifdef GEKKO
+	return net_listen(socket, queueLength);
+#else
 	return listen(socket, queueLength);
+#endif
 }
 
 static inline Socket SocketAccept(Socket socket, struct Address* address) {
 	if (!address) {
+#ifdef GEKKO
+		struct sockaddr_in addrInfo;
+		memset(&addrInfo, 0, sizeof(addrInfo));
+		socklen_t len = sizeof(addrInfo);
+		return net_accept(socket, (struct sockaddr*) &addrInfo, &len);
+#else
 		return accept(socket, 0, 0);
+#endif
 	}
 	if (address->version == IPV4) {
 		struct sockaddr_in addrInfo;
 		memset(&addrInfo, 0, sizeof(addrInfo));
 		addrInfo.sin_family = AF_INET;
 		addrInfo.sin_addr.s_addr = address->ipv4;
 		socklen_t len = sizeof(addrInfo);
+#ifdef GEKKO
+		return net_accept(socket, (struct sockaddr*) &addrInfo, &len);
+#else
 		return accept(socket, (struct sockaddr*) &addrInfo, &len);
-#ifndef _3DS
+#endif
+#if !defined(_3DS) && !defined(GEKKO)
 	} else {
 		struct sockaddr_in6 addrInfo;
 		memset(&addrInfo, 0, sizeof(addrInfo));
@@ -237,8 +292,12 @@ static inline int SocketSetBlocking(Socket socket, bool blocking) {
 #ifdef _WIN32
 	u_long unblocking = !blocking;
 	return ioctlsocket(socket, FIONBIO, &unblocking) == NO_ERROR;
+#else
+#ifdef GEKKO
+	int flags = net_fcntl(socket, F_GETFL, 0);
 #else
 	int flags = fcntl(socket, F_GETFL);
+#endif
 	if (flags == -1) {
 		return 0;
 	}
@@ -247,12 +306,20 @@ static inline int SocketSetBlocking(Socket socket, bool blocking) {
 	} else {
 		flags |= O_NONBLOCK;
 	}
+#ifdef GEKKO
+	return net_fcntl(socket, F_SETFL, flags) >= 0;
+#else
 	return fcntl(socket, F_SETFL, flags) >= 0;
 #endif
+#endif
 }
 
 static inline int SocketSetTCPPush(Socket socket, int push) {
+#ifdef GEKKO
+	return net_setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, (char*) &push, sizeof(int)) >= 0;
+#else
 	return setsockopt(socket, IPPROTO_TCP, TCP_NODELAY, (char*) &push, sizeof(int)) >= 0;
+#endif
 }
 
 static inline int SocketPoll(size_t nSockets, Socket* reads, Socket* writes, Socket* errors, int64_t timeoutMillis) {
@@ -304,7 +371,11 @@ static inline int SocketPoll(size_t nSockets, Socket* reads, Socket* writes, Soc
 	struct timeval tv;
 	tv.tv_sec = timeoutMillis / 1000;
 	tv.tv_usec = (timeoutMillis % 1000) * 1000;
+#ifdef GEKKO
+	int result = net_select(maxFd, &rset, &wset, &eset, timeoutMillis < 0 ? 0 : &tv);
+#else
 	int result = select(maxFd, &rset, &wset, &eset, timeoutMillis < 0 ? 0 : &tv);
+#endif
 	int r = 0;
 	int w = 0;
 	int e = 0;

src/arm/decoder-arm.c

@@ -214,6 +214,7 @@
 		0, \
 		ADDRESSING_MODE, CYCLES, TYPE, OTHER_AFFECTED) \
 	DEFINE_LOAD_STORE_DECODER_EX_ARM(NAME ## PUW, MNEMONIC, \
+		ARM_MEMORY_PRE_INCREMENT | \
 		ARM_MEMORY_WRITEBACK, \
 		ADDRESSING_MODE, CYCLES, TYPE, OTHER_AFFECTED) \
 

src/core/core.c

@@ -145,7 +145,10 @@ bool mCorePreloadVFCB(struct mCore* core, struct VFile* vf, void (cb)(size_t, si
 #ifdef FIXED_ROM_BUFFER
 	extern uint32_t* romBuffer;
 	extern size_t romBufferSize;
-	vfm = VFileFromMemory(romBuffer, romBufferSize);
+	if (size > romBufferSize) {
+		size = romBufferSize;
+	}
+	vfm = VFileFromMemory(romBuffer, size);
 #else
 	vfm = VFileMemChunk(NULL, size);
 #endif
@@ -373,9 +376,11 @@ bool mCoreLoadELF(struct mCore* core, struct ELF* elf) {
 		if (block && bsize >= phdr->p_filesz && esize > phdr->p_offset && esize >= phdr->p_filesz + phdr->p_offset) {
 			memcpy(block, &bytes[phdr->p_offset], phdr->p_filesz);
 		} else {
+			ELFProgramHeadersDeinit(&ph);
 			return false;
 		}
 	}
+	ELFProgramHeadersDeinit(&ph);
 	return true;
 }
 

src/gb/audio.c

@@ -117,7 +117,7 @@ void GBAudioReset(struct GBAudio* audio) {
 	if (audio->style == GB_AUDIO_GBA) {
 		mTimingSchedule(audio->timing, &audio->frameEvent, 0);
 	}
-	audio->ch1 = (struct GBAudioSquareChannel) { .envelope = { .dead = 2 } };
+	audio->ch1 = (struct GBAudioSquareChannel) { .sweep = { .time = 8 }, .envelope = { .dead = 2 } };
 	audio->ch2 = (struct GBAudioSquareChannel) { .envelope = { .dead = 2 } };
 	audio->ch3 = (struct GBAudioWaveChannel) { .bank = 0 };
 	audio->ch4 = (struct GBAudioNoiseChannel) { .nSamples = 0 };

src/gb/core.c

@@ -116,8 +116,10 @@ static void _GBCoreDeinit(struct mCore* core) {
 	GBDestroy(core->board);
 	mappedMemoryFree(core->cpu, sizeof(struct SM83Core));
 	mappedMemoryFree(core->board, sizeof(struct GB));
-#if defined USE_DEBUGGERS && (!defined(MINIMAL_CORE) || MINIMAL_CORE < 2)
+#if !defined(MINIMAL_CORE) || MINIMAL_CORE < 2
 	mDirectorySetDeinit(&core->dirs);
+#endif
+#ifdef USE_DEBUGGERS
 	if (core->symbolTable) {
 		mDebuggerSymbolTableDestroy(core->symbolTable);
 	}
@@ -275,6 +277,12 @@ static void _GBCoreReloadConfigOption(struct mCore* core, const char* option, co
 		}
 		return;
 	}
+	if (strcmp("sgb.borders", option) == 0) {
+		if (mCoreConfigGetIntValue(config, "sgb.borders", &fakeBool)) {
+			gb->video.sgbBorders = fakeBool;
+			gb->video.renderer->enableSGBBorder(gb->video.renderer, fakeBool);
+		}
+	}
 }
 
 static void _GBCoreDesiredVideoDimensions(struct mCore* core, unsigned* width, unsigned* height) {

src/gb/extra/proxy.c

@@ -44,6 +44,10 @@ void GBVideoProxyRendererCreate(struct GBVideoProxyRenderer* renderer, struct GB
 	renderer->d.getPixels = GBVideoProxyRendererGetPixels;
 	renderer->d.putPixels = GBVideoProxyRendererPutPixels;
 
+	renderer->d.disableBG = false;
+	renderer->d.disableWIN = false;
+	renderer->d.disableOBJ = false;
+
 	renderer->logger->context = renderer;
 	renderer->logger->parsePacket = _parsePacket;
 	renderer->logger->vramBlock = _vramBlock;
@@ -139,6 +143,9 @@ static bool _parsePacket(struct mVideoLogger* logger, const struct mVideoLoggerD
 		}
 		break;
 	case DIRTY_SCANLINE:
+		proxyRenderer->backend->disableBG = proxyRenderer->d.disableBG;
+		proxyRenderer->backend->disableWIN = proxyRenderer->d.disableWIN;
+		proxyRenderer->backend->disableOBJ = proxyRenderer->d.disableOBJ;
 		if (item->address < GB_VIDEO_VERTICAL_PIXELS) {
 			proxyRenderer->backend->finishScanline(proxyRenderer->backend, item->address);
 		}
@@ -231,6 +238,9 @@ void GBVideoProxyRendererWriteOAM(struct GBVideoRenderer* renderer, uint16_t oam
 void GBVideoProxyRendererDrawRange(struct GBVideoRenderer* renderer, int startX, int endX, int y, struct GBObj* obj, size_t oamMax) {
 	struct GBVideoProxyRenderer* proxyRenderer = (struct GBVideoProxyRenderer*) renderer;
 	if (!proxyRenderer->logger->block) {
+		proxyRenderer->backend->disableBG = proxyRenderer->d.disableBG;
+		proxyRenderer->backend->disableWIN = proxyRenderer->d.disableWIN;
+		proxyRenderer->backend->disableOBJ = proxyRenderer->d.disableOBJ;
 		proxyRenderer->backend->drawRange(proxyRenderer->backend, startX, endX, y, obj, oamMax);
 	}
 	mVideoLoggerWriteBuffer(proxyRenderer->logger, BUFFER_OAM, 0, oamMax * sizeof(*obj), obj);