WIP Gecko(ocarina) code support: There are a bunch code types that need coding/fixing/cleanup, but many codes should be functional. The game properties and "Cheats Manager"(formally Action Replay Manager) dialogs now have a "Gecko Codes" tab to view/enable/disable codes. Currently, you must click "Edit Config" and manually add your codes to the [Gecko] inifile section of your gameinis for them to be displayed.(same format as the AR codes) I'm going to add Add/Edit dialogs similar to the AR codes and support codes with modifiers. I added the new files to scons as best as I could without testing :p.

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5930 8ced0084-cf51-0410-be5f-012b33b47a6e
2025-07-28 08:39:49 -06:00 · 2010-07-22 01:48:48 +00:00
parent a103576a54
commit fb36de2338
16 changed files with 1325 additions and 13 deletions
--- a/Source/Core/Core/Src/GeckoCode.cpp
+++ b/Source/Core/Core/Src/GeckoCode.cpp
@ -0,0 +1,852 @@
+
+#include "GeckoCode.h"
+
+#include "Thread.h"
+#include "HW/Memmap.h"
+
+#include "vector"
+
+namespace Gecko
+{
+
+enum
+{
+	// Code Types
+	CODETYPE_WRITE_FILL =	0x0,
+	CODETYPE_IF =			0x1,
+	CODETYPE_BA_PO_OPS =	0x2,
+	CODETYPE_FLOW_CONTROL =	0x3,
+	CODETYPE_REGISTER_OPS =	0x4,
+	CODETYPE_SPECIAL_IF =	0x5,
+	CODETYPE_ASM_SWITCH_RANGE =	0x6,
+	CODETYPE_END_CODES =	0x7,
+
+	// Data Types
+	DATATYPE_8BIT =		0x0,
+	DATATYPE_16BIT =	0x1,
+	DATATYPE_32BIT =	0x2,
+};
+
+// globals
+static u32 base_address = 0;
+static u32 pointer_address = 0;
+static u32 gecko_register[0x10] = {0};
+static struct
+{
+	u32 address;
+	u32 number;
+} block[0x10];
+
+// codes execute when counter is 0
+static int	code_execution_counter = 0;
+
+// the currently active codes
+std::vector<GeckoCode>	active_codes;
+
+// return true if code execution is on
+inline bool CodeExecution()
+{
+	return (0 == code_execution_counter);
+}
+
+u32 GeckoCode::Code::GetAddress() const
+{
+	return gcaddress + (use_po ? pointer_address : (base_address & 0xFE000000));
+}
+
+static Common::CriticalSection active_codes_lock;
+
+// currently running code
+static GeckoCode::Code current_code;
+
+// Functions for each code type
+bool RamWriteAndFill();
+bool RegularIf();
+bool BaPoOps();
+bool FlowControl();
+bool RegisterOps();
+bool SpecialIf();
+bool AsmSwitchRange();
+bool EndCodes();
+
+bool MathOperation(u32& ret, const u32 left, const u32 right, const u8 type);
+
+void SetActiveCodes(const std::vector<GeckoCode>& gcodes)
+{
+	active_codes_lock.Enter();
+
+	active_codes.clear();
+	// add enabled codes
+	std::vector<GeckoCode>::const_iterator
+		gcodes_iter = gcodes.begin(),
+		gcodes_end = gcodes.end();
+	for (; gcodes_iter!=gcodes_end; ++gcodes_iter)
+		if (gcodes_iter->enabled)
+		{
+			// TODO: apply modifiers
+			// TODO: don't need description or creator string, just takin up memory
+			active_codes.push_back(*gcodes_iter);
+		}
+
+	active_codes_lock.Leave();
+}
+
+bool RunGeckoCode(const GeckoCode& gecko_code)
+{
+	static bool (*code_type_funcs[])(void) =
+	{ RamWriteAndFill, RegularIf, BaPoOps, FlowControl, RegisterOps, SpecialIf, AsmSwitchRange, EndCodes };
+
+	base_address = 0x80000000;
+	pointer_address = 0x80000000;
+	code_execution_counter = 0;
+
+	std::vector<GeckoCode::Code>::const_iterator
+		codes_iter = gecko_code.codes.begin(),
+		codes_end = gecko_code.codes.end();
+	for (; codes_iter != codes_end; ++codes_iter)
+	{
+		const GeckoCode::Code& code = *codes_iter;
+
+		current_code = code;
+
+		bool result = true;
+
+		switch (code.type)
+		{
+			// These codetypes run even if code_execution is off
+		case CODETYPE_IF :
+		case CODETYPE_FLOW_CONTROL :
+		case CODETYPE_SPECIAL_IF :
+		case CODETYPE_ASM_SWITCH_RANGE :
+		case CODETYPE_END_CODES :
+			result = code_type_funcs[code.type]();
+			break;
+
+			// The rest of the codetypes only run if code_execution is on
+		default :
+			if (CodeExecution())
+				result = code_type_funcs[code.type]();
+			break;
+		}
+
+		// code failed
+		if (false == result)
+		{
+			PanicAlert("GeckoCode failed to run (CT%i CST%i) (%s)"
+				"(Either a bad code or the code type is not yet supported.)"
+				, code.type, code.subtype, gecko_code.name.c_str());
+			return false;
+		}
+
+
+
+	}
+
+
+	return true;
+}
+
+bool RunActiveCodes()
+{
+	if (false == active_codes_lock.TryEnter())
+		return true;
+
+	std::vector<GeckoCode>::const_iterator
+		gcodes_iter = active_codes.begin(),
+		gcodes_end = active_codes.end();
+	for (; gcodes_iter!=gcodes_end; ++gcodes_iter)
+	{
+		RunGeckoCode(*gcodes_iter);
+		// we don't need to stop all codes if one fails, maybe
+		//if (false == RunGeckoCode(*gcodes_iter))
+			//return false;
+	}
+
+	active_codes_lock.Leave();
+	return true;
+}
+
+// CT0: Direct ram write/fill
+// NOT COMPLETE, last 2 subtypes not started
+bool RamWriteAndFill()
+{
+	const GeckoCode::Code& code = current_code;
+	u32 new_addr = code.GetAddress();
+	const u32& data = code.data;
+
+	u16 count = (data >> 16) + 1;
+
+	switch (code.subtype)
+	{
+		// CST0: 8bits Write & Fill
+	case 0x0 :
+		while (count--)
+		{
+			Memory::Write_U16((u16)data, new_addr);
+			++new_addr;
+		}
+		break;
+
+		// CST1: 16bits Write & Fill
+	case 0x1 :
+		while (count--)
+		{
+			Memory::Write_U16((u16)data, new_addr);
+			new_addr += 2;
+		}
+		break;
+
+		// CST2: 32bits Write
+	case 0x2 :
+		Memory::Write_U32((u32)data, new_addr);
+		break;
+
+		// CST3: String Code
+	case 0x3 :
+		// TODO:
+		return false;
+		break;
+
+		// CST4: Serial Code
+	case 0x4 :
+	{
+		// TODO: complete
+		u32 new_data = data;
+		
+
+		return false;
+	}
+		break;
+
+		// INVALID SUBTYPE
+	default :
+		return false;
+		break;
+	}
+
+	return true;
+}
+
+// CT1 Regular If codes (16/32 bits)
+// COMPLETE
+bool RegularIf()
+{
+	const GeckoCode::Code& code = current_code;
+
+	const bool is_endif = !!(code.address & 0x1);
+
+	// if code_execution is off and this is an endif, decrease the execution counter
+	if (false == CodeExecution())
+	{
+		if (is_endif)
+			--code_execution_counter;
+	}
+
+	bool result = false;
+
+	// if code_execution is on, execute the conditional
+	if (CodeExecution())
+	{
+		const u32 new_addr = code.GetAddress() & ~0x1;
+		const u32& data = code.data;
+
+		s32 read_value = 0;
+		s32 data_value = 0;
+
+		// 16bit vs 32bit
+		if (code.subtype & 0x4)
+		{
+			// 16bits
+			read_value = Memory::Read_U16(new_addr) & ~(data >> 16);
+			data_value = (data & 0xFFFF);
+		}
+		else
+		{
+			// 32bits
+			read_value = Memory::Read_U32(new_addr);
+			data_value = data;
+		}
+
+		switch (code.subtype & 0x3)
+		{
+			// CST0 : 32bits (endif, then) If equal
+			// CST4 : 16bits (endif, then) If equal
+		case 0x0 :
+			result = (read_value == data_value);
+			break;
+
+			// CST1 : 32bits (endif, then) If not equal
+			// CST5 : 16bits (endif, then) If not equal
+		case 0x1 :
+			result = (read_value != data_value);
+			break;
+
+			// CST2 : 32bits (endif, then) If greater
+			// CST6 : 16bits (endif, then) If greater
+		case 0x2 :
+			result = (read_value > data_value);
+			break;
+
+			// CST3 : 32bits (endif, then) If lower
+			// CST7 : 16bits (endif, then) If lower
+		case 0x3 :
+			result = (read_value < data_value);
+			break;	
+		}
+	}
+
+	// if the conditional returned false, or it never ran because execution is off,
+	// increase the code execution counter
+	if (false == result)
+		++code_execution_counter;
+
+	return true;
+}
+
+// CT2 Base Address/Pointer Operations
+// NOT COMPLETE, last 2 subtypes aren't done
+bool BaPoOps()
+{
+	const GeckoCode::Code& code = current_code;
+
+	// base_address vs pointer (ba vs po)
+	u32& change_address = (code.subtype & 0x4) ? pointer_address : base_address;
+
+	// 4STYZ00N XXXXXXXX
+	u32 new_data = code.data;
+
+	// append grN
+	if (code.z)
+		new_data += gecko_register[code.n];
+
+	// append ba or po (depending on last nibble's first bit)
+	if (code.y)
+		new_data += (code.use_po ? pointer_address : base_address);
+
+	// append to current value (not used in all subtypes, T will be 0 in those)
+	if (code.t)
+		new_data += change_address;
+
+	switch (code.subtype & 0x3)
+	{
+		// CST0 : Load into Base Address
+		// CST4 : Load into Pointer
+	case 0x0 :
+		change_address = Memory::Read_U32(new_data);
+		break;
+
+		// CST1 : Set Base Address to
+		// CST5 : Set Pointer to
+	case 0x1 :
+		change_address = new_data;
+		break;
+
+		// CST2 : Save Base Address to
+		// CST6 : Save Pointer to
+	case 0x2 :
+		Memory::Write_U32(change_address, new_data);
+		break;
+
+		// CST3 : Put next line of code location into the Base Address
+		// CST7 : Put grN's location into the Pointer
+
+		// conflicting documentation, one doc says CST7 is the same as CST3 but with po
+	case 0x3 :
+		// TODO:
+		return false;	//
+		break;
+	}
+
+	return true;
+}
+
+// CT3 Repeat/Goto/Gosub/Return
+// NOT COMPLETE
+bool FlowControl()
+{
+	const GeckoCode::Code& code = current_code;
+
+	// only the return subtype runs when code execution is off
+	if (false == CodeExecution() && code.subtype != 0x2)
+		return true;
+
+	// not all of these are used in all subtypes
+	const u8 block_num = (u8)(code.data & 0xF);
+	const s16 code_offset = (s16)code.address;
+
+	switch (code.subtype)
+	{
+		// CST0 : Set Repeat
+	case 0x0 :
+		// TODO: store address of next code as well
+		block[block_num].address = code.address & 0xFFFF;
+		// block[block_num].number = ;
+		return false; //
+		break;
+
+		// CST1 : Execute Repeat
+	case 0x1 :
+		if (block[block_num].number)
+		{
+			--block[block_num].number;
+			// TODO: jump to code block
+		}
+		return false;	//
+		break;
+
+		// CST2 : Return
+	case 0x2 :
+		if (((code.address >> 20) & 0xF) ^ (u32)CodeExecution())
+			// TODO: jump to block[block_num].number
+		return false;	//
+		break;
+
+		// CST3 : Goto
+	case 0x3 :
+		// TODO:
+		return false;	//
+		break;
+
+		// CST4 : Gosub
+	case 0x4 :
+		// TODO:
+		return false;	//
+		break;
+
+		// INVALID SUBTYPE
+	default :
+		return false;
+		break;
+	}
+
+	return true;
+}
+
+// CT4 Gecko Register Operations
+// NOT COMPLETE, need to do memory copy 1,2
+bool RegisterOps()
+{
+	const GeckoCode::Code& code = current_code;
+
+	// 80TYZZZN XXXXXXXX
+
+	u32 new_data = code.data;
+
+	// append ba or po (depending on last nibble's first bit)
+	if (code.y)
+		new_data += (code.use_po ? pointer_address : base_address);
+
+	u32& geckreg = gecko_register[code.n];
+
+	switch (code.subtype)
+	{
+		// CST0 : Set Gecko Register to
+	case 0x0 :
+		// append to or set register
+		geckreg = new_data + (code.t ? geckreg : 0);
+		break;
+
+		// CST1 : Load into Gecko Register
+	case 0x1 :
+		switch (code.t)
+		{
+			// 8bit
+		case DATATYPE_8BIT :
+			geckreg = Memory::Read_U8(new_data);
+			break;
+
+			// 16bit
+		case DATATYPE_16BIT :
+			geckreg = Memory::Read_U16(new_data);
+			break;
+
+			// 32bit
+		case DATATYPE_32BIT :
+			geckreg = Memory::Read_U32(new_data);
+			break;
+
+			// INVALID DATATYPE
+		default :
+			return false;
+			break;
+		}
+		break;
+
+		// CST2 : Save Gecko Register to
+	case 0x2 :
+		switch (code.t)
+		{
+			// 8bit
+		case DATATYPE_8BIT :
+			for (u16 i = 0; i <= code.z; ++i)
+				Memory::Write_U8((u8)geckreg, new_data + i);
+			break;
+
+			// 16bit
+		case DATATYPE_16BIT :
+			for (u16 i = 0; i <= code.z; ++i)
+				Memory::Write_U16((u16)geckreg, new_data + (i << 1));
+			break;
+
+			// 32bit
+		case DATATYPE_32BIT :
+			for (u16 i = 0; i <= code.z; ++i)
+				Memory::Write_U32((u32)geckreg, new_data + (i << 2));
+			break;
+
+			// INVALID DATATYPE
+		default :
+			return false;
+			break;
+		}
+		break;
+
+		// CST3 : Gecko Register / Direct Value operations
+		// CST4 : Gecko Registers operations
+	case 0x3 :
+	case 0x4 :
+	{
+		// subtype 3 uses value in .data subtype 4 uses register
+		u32 right_val = (code.subtype & 0x1 ? code.data : gecko_register[code.data & 0xF]);
+		if (code.y & 0x2)
+			right_val = Memory::Read_U32(right_val);
+
+		u32 left_val = geckreg;
+		if (code.y & 0x1)
+			left_val = Memory::Read_U32(left_val);
+
+		if (false == MathOperation(geckreg, left_val, right_val, code.t))
+			return false;
+	}
+		break;
+
+		// CST5 : Memory Copy 1
+	case 0x5 :
+		// TODO:
+		return false;	//
+		break;
+
+		// CST6 : Memory Copy 2
+	case 0x6 :
+		// TODO:
+		return false;	//
+		break;
+
+		// INVALID SUBTYPE
+	default :
+		return false;
+		break;
+
+	}
+
+	return true;
+}
+
+// NOT COMPLETE, at least one op needs to be coded/fixed
+bool MathOperation(u32& ret, const u32 left, const u32 right, const u8 type)
+{
+	// ? = T :
+	switch (type)
+	{
+		// 0 : add (+)
+	case 0x0 :
+		ret = left + right;
+		break;
+
+		// 1 : mul (*)
+	case 0x1 :
+		ret = left * right;
+		break;
+
+		// 2 : or (|)
+	case 0x2 :
+		ret = left | right;
+		break;
+
+		// 3 : and (&)
+	case 0x3 :
+		ret = left & right;
+		break;
+
+		// 4 : xor (^)
+	case 0x4 :
+		ret = left ^ right;
+		break;
+
+		// 5 : slw (<<)
+	case 0x5 :
+		ret = left << right;
+		break;
+
+		// 6 : srw (>>)
+	case 0x6 :
+		ret = left >> right;
+		break;
+
+		// TODO: this one good?
+		// 7 : rol (rotate left)
+	case 0x7 :
+		ret = (left << right) | (left >> (8 - right));
+		break;
+
+		// 8 : asr (arithmetic shift right)
+	case 0x8 :
+		// TODO: wuts this
+		return false;
+		break;
+
+		// TODO: these float ops good?
+		// A : fadds (single float add)
+	case 0xA :
+		*(float*)&ret = *(float*)&left + *(float*)&right;
+		break;
+
+		// B : fmuls (single float mul)
+	case 0xB :
+		*(float*)&ret = *(float*)&left * *(float*)&right;
+		break;
+
+		// INVALID OPERATION TYPE
+	default :
+		return false;
+		break;
+	}
+
+	return true;
+}
+
+// CT5: Special If codes (16bits)
+// NOT COMPLETE, part 2 (counter stuff) not started
+bool SpecialIf()
+{
+	const GeckoCode::Code& code = current_code;
+
+	const bool is_endif = !!(code.address & 0x1);
+
+	// if code_execution is off and this is an endif, decrease the execution counter
+	if (false == CodeExecution())
+	{
+		if (is_endif)
+			--code_execution_counter;
+	}
+
+	bool result = false;
+
+	// if code_execution is on, execute the conditional
+	if (CodeExecution())
+	{
+		const u32 addr = code.GetAddress() & ~0x1;
+		const u32& data = code.data;
+
+		// A-______ NM00YYYY
+
+		if (code.subtype ^ 0x4)
+		{
+			// CT5 Part1 : Unknown values comparison
+
+			const u8 n = (u8)(data >> 28);
+			const u8 m = (u8)((data >> 24) & 0xF);
+			const u16 y = (u16)data;
+
+			// TODO: should these be signed? probably?
+			const s16 left_val = Memory::Read_U16(((0xF == n) ? addr : gecko_register[n]) & ~y);
+			const s16 right_val = Memory::Read_U16(((0xF == m) ? addr : gecko_register[m]) & ~y);
+
+			switch (code.subtype)
+			{
+				// CST0 : 16bits (endif, then) If equal
+			case 0x0 :
+				result = (left_val == right_val);
+				break;
+
+				// CST1 : 16bits (endif, then) If not equal
+			case 0x1 :
+				result = (left_val != right_val);
+				break;
+
+				// CST2 : 16bits (endif, then) If greater
+			case 0x2 :
+				result = (left_val > right_val);
+				break;
+
+				// CST3 : 16bits (endif, then) If lower
+			case 0x3 :
+				result = (left_val < right_val);
+				break;
+			}
+		}
+		else
+		{
+			// CT5 Part2 : 16bits Counter check
+			// TODO:
+
+			const u16 z = (u16)(data >> 16);
+
+			switch (code.subtype)
+			{
+				// CST4 : 16bits (endif, then) If counter value equal
+			case 0x4 :
+				// TODO:
+				return false;	//
+				break;
+
+				// CST5 : 16bits (endif, then) If counter value not equal
+			case 0x5 :
+				// TODO:
+				return false;	//
+				break;
+
+				// CST6 : 16bits (endif, then) If counter value greater
+			case 0x6 :
+				// TODO:
+				return false;	//
+				break;
+
+				// CST7 : 16bits (endif, then) If counter value lower
+			case 0x7 :
+				// TODO:
+				return false;	//
+				break;
+			}
+		}
+	}
+
+	// if the conditional returned false, or it never ran because execution is off, increase the code execution counter
+	if (false == result)
+		++code_execution_counter;
+
+	return true;
+}
+
+// CT6 ASM Codes, On/Off switch and Address Range Check
+// NOT COMPLETE, hardly started
+// fix the logic flow in this one
+bool AsmSwitchRange()
+{
+	const GeckoCode::Code& code = current_code;
+
+	// only used for the last 2 subtypes
+	const bool is_endif = !!(code.address & 0x1);
+
+	// only run if code_execution is set or this code is a switch or rangecheck subtype
+	// the switch and rangecheck run if exectution_counter is 1 (directly inside the failed if) if they are an endif
+	if (false == CodeExecution())
+	{
+		if (code.subtype < 0x6)
+			return true;
+		else if (false == (1 == code_execution_counter && is_endif))
+			return true;
+	}
+
+	const u32& data = code.data;
+
+	switch (code.subtype)
+	{
+		// CST0 : Execute following ASM Code
+	case 0x0 :
+		// TODO:
+		return false;	//
+		break;
+
+		// CST1 : Insert ASM code in the game
+	case 0x1 :
+		// TODO:
+		return false;
+		break;
+
+		// CST3 : Create a branch
+	case 0x3 :
+		// TODO:
+		return false;	//
+		break;
+
+		// CST6 : On/Off switch
+	case 0x6 :
+		// TODO:
+		return false;	//
+		break;
+
+		// CST7 : Address range check (If... code)
+	case 0x7 :
+		if (code_execution_counter)
+		{
+			const u32 addr = (code.use_po ? pointer_address : base_address);
+			if (addr >= (data & 0xFFFF0000) && addr <= (data << 16))
+				--code_execution_counter;
+		}
+		break;
+
+		// INVALID SUBTYPE
+	default :
+		return false;
+		break;
+	}
+
+	return true;
+}
+
+// CT7 End of codes, Endif (Else)
+// COMPLETE, maybe
+bool EndCodes()
+{
+	const GeckoCode::Code& code = current_code;
+	const u32& data = code.data;
+
+	const u32 x = (data & 0xFFFF0000);
+	const u32 y = (data << 16);
+
+	// these 2 do not happen in the "CST7 : End of Code", but in that subtype they will be 0
+	if (x)
+		base_address = x;
+	if (y)
+		pointer_address = y;
+
+	switch (code.subtype)
+	{
+		// CST0 : Full Terminator
+	case 0x0 :
+		// clears the code execution status
+		// TODO: should this always stop all codes, even if execution is off?
+		if (CodeExecution())
+			code_execution_counter = -1;	// silly maybe
+		break;
+
+		// CST1 : Endif (+else)
+	case 0x1 :
+	{
+		// apply endifs
+		const u8 v = (u8)code.address;
+		if (code_execution_counter >= v)
+			code_execution_counter -= v;
+		else
+		{
+			// too many endifs
+			return false;
+		}
+
+		const bool is_else = !!(code.address & 0x00100000);
+		// apply else
+		if (is_else)
+			if (code_execution_counter <= 1)
+				code_execution_counter ^= 1;
+	}
+		break;
+
+		// CST7 : End of Code
+	case 0x7 :
+		// tell the code handler that there are no more codes in the code list
+		// TODO: should this always stop all codes, even if execution is off?
+		if (CodeExecution())
+			code_execution_counter = -1;	// silly maybe
+		break;
+
+		// INVALID SUBTYPE
+	default :
+		return false;
+		break;
+	}
+
+	return true;
+}
+
+}	// namespace Gecko