GBA: Make idle loop detection configurable

src/gba/gba-config.c

@@ -212,6 +212,18 @@ void GBAConfigMap(const struct GBAConfig* config, struct GBAOptions* opts) {
 	_lookupIntValue(config, "fullscreen", &opts->fullscreen);
 	_lookupIntValue(config, "width", &opts->width);
 	_lookupIntValue(config, "height", &opts->height);
+
+	char* idleOptimization;
+	if (_lookupCharValue(config, "idleOptimization", &idleOptimization)) {
+		if (strcasecmp(idleOptimization, "ignore") == 0) {
+			opts->idleOptimization = IDLE_LOOP_IGNORE;
+		} else if (strcasecmp(idleOptimization, "remove") == 0) {
+			opts->idleOptimization = IDLE_LOOP_REMOVE;
+		} else if (strcasecmp(idleOptimization, "detect") == 0) {
+			opts->idleOptimization = IDLE_LOOP_DETECT;
+		}
+		free(idleOptimization);
+	}
 }
 
 void GBAConfigLoadDefaults(struct GBAConfig* config, const struct GBAOptions* opts) {
@@ -231,6 +243,18 @@ void GBAConfigLoadDefaults(struct GBAConfig* config, const struct GBAOptions* op
 	ConfigurationSetIntValue(&config->defaultsTable, 0, "height", opts->height);
 	ConfigurationSetIntValue(&config->defaultsTable, 0, "lockAspectRatio", opts->lockAspectRatio);
 	ConfigurationSetIntValue(&config->defaultsTable, 0, "resampleVideo", opts->resampleVideo);
+
+	switch (opts->idleOptimization) {
+	case IDLE_LOOP_IGNORE:
+		ConfigurationSetValue(&config->defaultsTable, 0, "idleOptimization", "ignore");
+		break;
+	case IDLE_LOOP_REMOVE:
+		ConfigurationSetValue(&config->defaultsTable, 0, "idleOptimization", "remove");
+		break;
+	case IDLE_LOOP_DETECT:
+		ConfigurationSetValue(&config->defaultsTable, 0, "idleOptimization", "detect");
+		break;
+	}
 }
 
 void GBAConfigFreeOpts(struct GBAOptions* opts) {

src/gba/gba-config.h

@@ -8,6 +8,8 @@
 
 #include "util/common.h"
 
+#include "gba.h"
+
 #include "util/configuration.h"
 
 struct GBAConfig {
@@ -35,6 +37,8 @@ struct GBAOptions {
 
 	bool videoSync;
 	bool audioSync;
+
+	enum GBAIdleLoopOptimization idleOptimization;
 };
 
 void GBAConfigInit(struct GBAConfig*, const char* port);

src/gba/gba-memory.c

@@ -173,7 +173,7 @@ static void _analyzeForIdleLoop(struct GBA* gba, struct ARMCore* cpu, uint32_t a
 				break;
 			case ARM_BRANCH:
 				if ((uint32_t) info.op1.immediate + nextAddress + WORD_SIZE_THUMB * 2 == address) {
-					gba->busyLoop = address;
+					gba->idleLoop = address;
 				}
 				gba->idleDetectionStep = -1;
 				return;
@@ -191,32 +191,36 @@ static void GBASetActiveRegion(struct ARMCore* cpu, uint32_t address) {
 	struct GBA* gba = (struct GBA*) cpu->master;
 	struct GBAMemory* memory = &gba->memory;
 
-	if (address == gba->lastJump && address == gba->busyLoop && memory->activeRegion != REGION_BIOS) {
-		GBAHalt(gba);
-	}
-
 	int newRegion = address >> BASE_OFFSET;
-	if (newRegion == memory->activeRegion) {
-		if (address == gba->lastJump) {
-			switch (gba->idleDetectionStep) {
-			case 0:
-				memcpy(gba->cachedRegisters, cpu->gprs, sizeof(gba->cachedRegisters));
-				++gba->idleDetectionStep;
-				break;
-			case 1:
-				if (memcmp(gba->cachedRegisters, cpu->gprs, sizeof(gba->cachedRegisters))) {
-					gba->idleDetectionStep = -1;
+	if (gba->idleOptimization >= IDLE_LOOP_REMOVE) {
+		if (address == gba->lastJump && address == gba->idleLoop && memory->activeRegion != REGION_BIOS) {
+			GBAHalt(gba);
+		} else if (gba->idleOptimization >= IDLE_LOOP_DETECT && newRegion == memory->activeRegion) {
+			if (address == gba->lastJump) {
+				switch (gba->idleDetectionStep) {
+				case 0:
+					memcpy(gba->cachedRegisters, cpu->gprs, sizeof(gba->cachedRegisters));
+					++gba->idleDetectionStep;
+					break;
+				case 1:
+					if (memcmp(gba->cachedRegisters, cpu->gprs, sizeof(gba->cachedRegisters))) {
+						gba->idleDetectionStep = -1;
+						break;
+					}
+					_analyzeForIdleLoop(gba, cpu, address);
 					break;
 				}
-				_analyzeForIdleLoop(gba, cpu, address);
-				break;
+			} else {
+				gba->idleDetectionStep = 0;
 			}
-		} else {
-			gba->lastJump = address;
-			gba->idleDetectionStep = 0;
 		}
+	}
+
+	gba->lastJump = address;
+	if (newRegion == memory->activeRegion) {
 		return;
 	}
+
 	if (memory->activeRegion == REGION_BIOS) {
 		memory->biosPrefetch = cpu->prefetch[1];
 	}

src/gba/gba-overrides.c

@@ -195,5 +195,5 @@ void GBAOverrideApply(struct GBA* gba, const struct GBACartridgeOverride* overri
 		GBAGPIOInitTilt(&gba->memory.gpio);
 	}
 
-	gba->busyLoop = override->idleLoop;
+	gba->idleLoop = override->idleLoop;
 }

src/gba/gba-thread.c

@@ -173,6 +173,7 @@ static THREAD_ENTRY _GBAThreadRun(void* context) {
 	GBASIOSetDriverSet(&gba.sio, &threadContext->sioDrivers);
 
 	gba.keySource = &threadContext->activeKeys;
+	gba.idleOptimization = threadContext->idleOptimization;
 
 	if (threadContext->startCallback) {
 		threadContext->startCallback(threadContext);
@@ -261,6 +262,8 @@ void GBAMapOptionsToContext(const struct GBAOptions* opts, struct GBAThread* thr
 	if (opts->audioBuffers) {
 		threadContext->audioBuffers = opts->audioBuffers;
 	}
+
+	threadContext->idleOptimization = opts->idleOptimization;
 }
 
 void GBAMapArgumentsToContext(const struct GBAArguments* args, struct GBAThread* threadContext) {

src/gba/gba-thread.h

@@ -71,6 +71,7 @@ struct GBAThread {
 	int activeKeys;
 	struct GBAAVStream* stream;
 	struct Configuration* overrides;
+	enum GBAIdleLoopOptimization idleOptimization;
 
 	// Run-time options
 	int frameskip;

src/gba/gba.c

@@ -75,7 +75,10 @@ static void GBAInit(struct ARMCore* cpu, struct ARMComponent* component) {
 
 	gba->biosChecksum = GBAChecksum(gba->memory.bios, SIZE_BIOS);
 
-	gba->busyLoop = -1;
+	gba->idleOptimization = IDLE_LOOP_REMOVE;
+	gba->idleLoop = -1;
+	gba->lastJump = 0;
+	gba->idleDetectionStep = 0;
 }
 
 void GBADestroy(struct GBA* gba) {

src/gba/gba.h

@@ -75,6 +75,12 @@ enum GBAComponent {
 	GBA_COMPONENT_MAX
 };
 
+enum GBAIdleLoopOptimization {
+	IDLE_LOOP_IGNORE = -1,
+	IDLE_LOOP_REMOVE = 0,
+	IDLE_LOOP_DETECT
+};
+
 enum {
 	SP_BASE_SYSTEM = 0x03007F00,
 	SP_BASE_IRQ = 0x03007FA0,
@@ -135,7 +141,8 @@ struct GBA {
 
 	int logLevel;
 
-	uint32_t busyLoop;
+	enum GBAIdleLoopOptimization idleOptimization;
+	uint32_t idleLoop;
 	uint32_t lastJump;
 	int idleDetectionStep;
 	int32_t cachedRegisters[16];