Import TRK 2.6

config/GMPE01_00/splits.txt

@@ -1186,7 +1186,7 @@ TRK_MINNOW_DOLPHIN/serpoll.c:
 	.text       start:0x800ECC5C end:0x800ED028
 	.bss        start:0x801A9110 end:0x801A9128
 
-TRK_MINNOW_DOLPHIN/usrput.c:
+TRK_MINNOW_DOLPHIN/usr_put.c:
 	.text       start:0x800ED028 end:0x800ED0B4
 
 TRK_MINNOW_DOLPHIN/dispatch.c:
@@ -1224,7 +1224,7 @@ TRK_MINNOW_DOLPHIN/targimpl.c:
 TRK_MINNOW_DOLPHIN/targsupp.c:
 	.text       start:0x800F1CF0 end:0x800F1D10
 
-TRK_MINNOW_DOLPHIN/__exception.c:
+TRK_MINNOW_DOLPHIN/__exception.s:
 	.init       start:0x80003534 end:0x80005468
 
 TRK_MINNOW_DOLPHIN/dolphin_trk.c:

config/GMPE01_01/splits.txt

@@ -1186,7 +1186,7 @@ TRK_MINNOW_DOLPHIN/serpoll.c:
 	.text       start:0x800ECC5C end:0x800ED028
 	.bss        start:0x801A9110 end:0x801A9128
 
-TRK_MINNOW_DOLPHIN/usrput.c:
+TRK_MINNOW_DOLPHIN/usr_put.c:
 	.text       start:0x800ED028 end:0x800ED0B4
 
 TRK_MINNOW_DOLPHIN/dispatch.c:
@@ -1224,7 +1224,7 @@ TRK_MINNOW_DOLPHIN/targimpl.c:
 TRK_MINNOW_DOLPHIN/targsupp.c:
 	.text       start:0x800F1CF0 end:0x800F1D10
 
-TRK_MINNOW_DOLPHIN/__exception.c:
+TRK_MINNOW_DOLPHIN/__exception.s:
 	.init       start:0x80003534 end:0x80005468
 
 TRK_MINNOW_DOLPHIN/dolphin_trk.c:

configure.py

@@ -242,6 +242,9 @@ cflags_trk = [
     "-sdata 0",
     "-sdata2 0",
     "-inline auto,deferred",
+    "-pool off",
+    "-enum min",
+    "-sdatathreshold 0"
 ]
 
 cflags_odemuexi = [
@@ -731,28 +734,28 @@ config.libs = [
         "cflags": cflags_trk,
         "host": False,
         "objects": [
-            Object(NonMatching, "TRK_MINNOW_DOLPHIN/mainloop.c"),
+            Object(MatchingFor("GMPE01_00", "GMPE01_01"), "TRK_MINNOW_DOLPHIN/mainloop.c"),
-            Object(NonMatching, "TRK_MINNOW_DOLPHIN/nubevent.c"),
+            Object(MatchingFor("GMPE01_00", "GMPE01_01"), "TRK_MINNOW_DOLPHIN/nubevent.c"),
-            Object(NonMatching, "TRK_MINNOW_DOLPHIN/nubinit.c"),
+            Object(MatchingFor("GMPE01_00", "GMPE01_01"), "TRK_MINNOW_DOLPHIN/nubinit.c"),
             Object(NonMatching, "TRK_MINNOW_DOLPHIN/msg.c"),
             Object(NonMatching, "TRK_MINNOW_DOLPHIN/msgbuf.c"),
             Object(NonMatching, "TRK_MINNOW_DOLPHIN/serpoll.c"),
-            Object(NonMatching, "TRK_MINNOW_DOLPHIN/usrput.c"),
+            Object(NonMatching, "TRK_MINNOW_DOLPHIN/usr_put.c"),
             Object(NonMatching, "TRK_MINNOW_DOLPHIN/dispatch.c"),
             Object(NonMatching, "TRK_MINNOW_DOLPHIN/msghndlr.c"),
             Object(NonMatching, "TRK_MINNOW_DOLPHIN/support.c"),
-            Object(NonMatching, "TRK_MINNOW_DOLPHIN/mutex_TRK.c"),
+            Object(MatchingFor("GMPE01_00", "GMPE01_01"), "TRK_MINNOW_DOLPHIN/mutex_TRK.c"),
             Object(NonMatching, "TRK_MINNOW_DOLPHIN/notify.c"),
-            Object(NonMatching, "TRK_MINNOW_DOLPHIN/flush_cache.c"),
+            Object(MatchingFor("GMPE01_00", "GMPE01_01"), "TRK_MINNOW_DOLPHIN/flush_cache.c"),
             Object(NonMatching, "TRK_MINNOW_DOLPHIN/mem_TRK.c"),
             Object(NonMatching, "TRK_MINNOW_DOLPHIN/targimpl.c"),
             Object(NonMatching, "TRK_MINNOW_DOLPHIN/targsupp.c"),
-            Object(NonMatching, "TRK_MINNOW_DOLPHIN/__exception.c"),
+            Object(MatchingFor("GMPE01_00", "GMPE01_01"), "TRK_MINNOW_DOLPHIN/__exception.s"),
             Object(NonMatching, "TRK_MINNOW_DOLPHIN/dolphin_trk.c"),
-            Object(NonMatching, "TRK_MINNOW_DOLPHIN/mpc_7xx_603e.c"),
+            Object(MatchingFor("GMPE01_00", "GMPE01_01"), "TRK_MINNOW_DOLPHIN/mpc_7xx_603e.c"),
-            Object(NonMatching, "TRK_MINNOW_DOLPHIN/main_TRK.c"),
+            Object(MatchingFor("GMPE01_00", "GMPE01_01"), "TRK_MINNOW_DOLPHIN/main_TRK.c"),
             Object(NonMatching, "TRK_MINNOW_DOLPHIN/dolphin_trk_glue.c"),
-            Object(NonMatching, "TRK_MINNOW_DOLPHIN/targcont.c"),
+            Object(MatchingFor("GMPE01_00", "GMPE01_01"), "TRK_MINNOW_DOLPHIN/targcont.c"),
             Object(NonMatching, "TRK_MINNOW_DOLPHIN/target_options.c"),
             Object(NonMatching, "TRK_MINNOW_DOLPHIN/mslsupp.c"),
         ],

include/OdemuExi2/odemuexi/DebuggerDriver.h

@@ -0,0 +1,24 @@
+#ifndef ODEMUEXI_DEBUGGER_DRIVER_H
+#define ODEMUEXI_DEBUGGER_DRIVER_H
+
+#include <dolphin/os.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int Hu_IsStub();
+
+void DBInitComm(volatile u8** param_1, __OSInterruptHandler param_2);
+void DBInitInterrupts(void);
+u32 DBQueryData(void);
+int DBRead(void* data, u32 size);
+int DBWrite(const void* data, u32 size);
+void DBOpen(void);
+void DBClose(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/PowerPC_EABI_Support/MetroTRK/trk.h

@@ -0,0 +1,381 @@
+#ifndef __METROTRK_TRK_H__
+#define __METROTRK_TRK_H__
+
+#include "dolphin/types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//////////// TRK ENUMS /////////////
+// Hardware types.
+typedef enum {
+	HARDWARE_AMC_DDH = 0,
+	HARDWARE_GDEV    = 1,
+	HARDWARE_BBA     = 2,
+} HardwareType;
+
+// DS Error returns.
+enum {
+	DS_NoError        = 0x0,
+	DS_StepError      = 0x1,
+	DS_ParameterError = 0x2,
+
+	DS_EventQueueFull = 0x100,
+
+	DS_NoMessageBufferAvailable = 0x300,
+	DS_MessageBufferOverflow    = 0x301,
+	DS_MessageBufferReadError   = 0x302,
+
+	DS_DispatchError = 0x500,
+
+	DS_InvalidMemory    = 0x700,
+	DS_InvalidRegister  = 0x701,
+	DS_CWDSException    = 0x702,
+	DS_UnsupportedError = 0x703,
+	DS_InvalidProcessID = 0x704,
+	DS_InvalidThreadID  = 0x705,
+	DS_OSError          = 0x706,
+
+	DS_Error800 = 0x800,
+};
+
+typedef int DSError;
+
+// Where to read/write.
+typedef enum {
+	DS_Stdin  = 0,
+	DS_Stdout = 1,
+	DS_Stderr = 2,
+} DSFileHandle;
+
+// IO returns.
+typedef enum {
+	DS_IONoError = 0,
+	DS_IOError   = 1,
+	DS_IOEOF     = 2,
+} DSIOResult;
+
+// Message command IDs
+typedef enum {
+	DSMSG_Ping        = 0x0,
+	DSMSG_Connect     = 0x1,
+	DSMSG_Disconnect  = 0x2,
+	DSMSG_Reset       = 0x3,
+	DSMSG_Versions    = 0x4,
+	DSMSG_SupportMask = 0x5,
+	DSMSG_Override    = 0x7,
+
+	DSMSG_ReadMemory     = 0x10,
+	DSMSG_WriteMemory    = 0x11,
+	DSMSG_ReadRegisters  = 0x12,
+	DSMSG_WriteRegisters = 0x13,
+	DSMSG_SetOption      = 0x17,
+	DSMSG_Continue       = 0x18,
+	DSMSG_Step           = 0x19,
+	DSMSG_Stop           = 0x1A,
+
+	DSMSG_ReplyACK = 0x80,
+
+	DSMSG_NotifyStopped   = 0x90,
+	DSMSG_NotifyException = 0x91,
+
+	DSMSG_WriteFile    = 0xD0,
+	DSMSG_ReadFile     = 0xD1,
+	DSMSG_OpenFile     = 0xD2,
+	DSMSG_CloseFile    = 0xD3,
+	DSMSG_PositionFile = 0xD4,
+
+	DSMSG_ReplyNAK = 0xFF,
+} MessageCommandID;
+
+// Register commands.
+typedef enum {
+	DSREG_Default   = 0,
+	DSREG_FP        = 1,
+	DSREG_Extended1 = 2,
+	DSREG_Extended2 = 3,
+} DSMessageRegisterOptions;
+
+// Step commands.
+typedef enum {
+	DSSTEP_IntoCount = 0x0,
+	DSSTEP_IntoRange = 0x1,
+	DSSTEP_OverCount = 0x10,
+	DSSTEP_OverRange = 0x11,
+} DSMessageStepOptions;
+
+typedef enum {
+	DSREPLY_NoError         = 0x0,
+	DSREPLY_Error           = 0x1,
+	DSREPLY_PacketSizeError = 0x2,
+	DSREPLY_CWDSError       = 0x3,
+	DSREPLY_EscapeError     = 0x4,
+	DSREPLY_BadFCS          = 0x5,
+	DSREPLY_Overflow        = 0x6,
+	DSREPLY_SequenceMissing = 0x7,
+
+	DSREPLY_UnsupportedCommandError = 0x10,
+	DSREPLY_ParameterError          = 0x11,
+	DSREPLY_UnsupportedOptionError  = 0x12,
+	DSREPLY_InvalidMemoryRange      = 0x13,
+	DSREPLY_InvalidRegisterRange    = 0x14,
+	DSREPLY_CWDSException           = 0x15,
+	DSREPLY_NotStopped              = 0x16,
+	DSREPLY_BreakpointsFull         = 0x17,
+	DSREPLY_BreakpointConflict      = 0x18,
+
+	DSREPLY_OSError            = 0x20,
+	DSREPLY_InvalidProcessID   = 0x21,
+	DSREPLY_InvalidThreadID    = 0x22,
+	DSREPLY_DebugSecurityError = 0x23,
+} DSReplyError;
+
+typedef enum {
+	DSRECV_Wait          = 0,
+	DSRECV_Found         = 1,
+	DSRECV_InFrame       = 2,
+	DSRECV_FrameOverflow = 3,
+} ReceiverState;
+
+typedef enum {
+	DSMSGMEMORY_Segmented     = 0x01, /* non-flat addr space */
+	DSMSGMEMORY_Extended      = 0x02, /* > 32-bit data addr */
+	DSMSGMEMORY_Protected     = 0x04, /* non-user memory */
+	DSMSGMEMORY_Userview      = 0x08, /* breakpoints are invisible */
+	DSMSGMEMORY_Space_program = 0x00,
+	DSMSGMEMORY_Space_data    = 0x40,
+	DSMSGMEMORY_Space_io      = 0x80
+};
+
+typedef enum {
+	NUBEVENT_Null       = 0,
+	NUBEVENT_Shutdown   = 1,
+	NUBEVENT_Request    = 2,
+	NUBEVENT_Breakpoint = 3,
+	NUBEVENT_Exception  = 4,
+	NUBEVENT_Support    = 5,
+} NubEventType;
+
+typedef enum {
+	VALIDMEM_Readable  = 0,
+	VALIDMEM_Writeable = 1,
+} ValidMemoryOptions;
+
+typedef enum {
+	MEMACCESS_UserMemory     = 0,
+	MEMACCESS_DebuggerMemory = 1,
+} MemoryAccessOptions;
+
+typedef int UARTError;
+
+typedef enum {
+	UART_NoError            = 0,
+	UART_UnknownBaudRate    = 1,
+	UART_ConfigurationError = 2,
+	UART_BufferOverflow     = 3, // specified buffer was too small
+	UART_NoData             = 4, // no data available from polling
+} UARTErrorOptions;
+
+typedef enum {
+	kBaudHWSet  = -1,  // use HW settings such as DIP switches
+	kBaud300    = 300, // valid baud rates
+	kBaud600    = 600,
+	kBaud1200   = 1200,
+	kBaud1800   = 1800,
+	kBaud2000   = 2000,
+	kBaud2400   = 2400,
+	kBaud3600   = 3600,
+	kBaud4800   = 4800,
+	kBaud7200   = 7200,
+	kBaud9600   = 9600,
+	kBaud19200  = 19200,
+	kBaud38400  = 38400,
+	kBaud57600  = 57600,
+	kBaud115200 = 115200,
+	kBaud230400 = 230400
+} UARTBaudRate;
+
+////////////////////////////////////
+
+typedef int MessageBufferID;
+
+#define TRKMSGBUF_SIZE (0x800 + 0x80)
+
+typedef struct TRKBuffer {
+	/* 0x00 */ u32 mutex;
+	/* 0x04 */ BOOL isInUse;
+	/* 0x08 */ u32 length;
+	/* 0x0C */ u32 position;
+	/* 0x10 */ u8 data[TRKMSGBUF_SIZE];
+} TRKBuffer;
+
+typedef struct TRKFramingState {
+	MessageBufferID msgBufID;   // _00
+	TRKBuffer* buffer;          // _04
+	ReceiverState receiveState; // _08
+	BOOL isEscape;              // _0C
+	u8 fcsType;                 // _10
+} TRKFramingState;
+
+typedef struct TRKState_PPC {
+	u32 GPR[32];         // 0x0
+	u32 LR;              // 0x80
+	u32 CTR;             // 0x84
+	u32 XER;             // 0x88
+	u32 MSR;             // 0x8c
+	u32 DAR;             // 0x90
+	u32 DSISR;           // 0x94
+	BOOL stopped;        // 0x98
+	BOOL inputActivated; // 0x9c
+	u8* inputPendingPtr; // 0xA0
+} TRKState_PPC;
+
+typedef struct CommandReply {
+	u32 _00; // _00
+	union {
+		u8 b;
+		MessageCommandID m;
+	} commandID; // _04, use MessageCommandID enum
+	union {
+		u8 b;
+		DSReplyError r;
+	} replyError; // _08, use DSReplyError enum - should be enum type? check
+	              // size.
+	u32 _0C;      // _0C
+	u8 _10[0x30]; // _10, unknown
+} CommandReply;
+
+typedef struct ProcessorRestoreFlags_PPC {
+	u8 TBR;
+	u8 DEC;
+	u8 linker_padding[0x9 - 0x2];
+} ProcessorRestoreFlags_PPC;
+
+void TRKSaveExtended1Block();
+
+#define SPR_XER    1
+#define SPR_LR     8
+#define SPR_CTR    9
+#define SPR_DSISR  18
+#define SPR_DAR    19
+#define SPR_DEC    22
+#define SPR_SDR1   25
+#define SPR_SRR0   26
+#define SPR_SRR1   27
+#define SPR_SPRG0  272
+#define SPR_SPRG1  273
+#define SPR_SPRG2  274
+#define SPR_SPRG3  275
+#define SPR_EAR    282
+#define SPR_TBL    284
+#define SPR_TBU    285
+#define SPR_PVR    287
+#define SPR_IBAT0U 528
+#define SPR_IBAT0L 529
+#define SPR_IBAT1U 530
+#define SPR_IBAT1L 531
+#define SPR_IBAT2U 532
+#define SPR_IBAT2L 533
+#define SPR_IBAT3U 534
+#define SPR_IBAT3L 535
+#define SPR_IBAT4U 560
+#define SPR_IBAT4L 561
+#define SPR_IBAT5U 562
+#define SPR_IBAT5L 563
+#define SPR_IBAT6U 564
+#define SPR_IBAT6L 565
+#define SPR_IBAT7U 566
+#define SPR_IBAT7L 567
+#define SPR_DBAT0U 536
+#define SPR_DBAT0L 537
+#define SPR_DBAT1U 538
+#define SPR_DBAT1L 539
+#define SPR_DBAT2U 540
+#define SPR_DBAT2L 541
+#define SPR_DBAT3U 542
+#define SPR_DBAT3L 543
+#define SPR_DBAT4U 568
+#define SPR_DBAT4L 569
+#define SPR_DBAT5U 570
+#define SPR_DBAT5L 571
+#define SPR_DBAT6U 572
+#define SPR_DBAT6L 573
+#define SPR_DBAT7U 574
+#define SPR_DBAT7L 575
+#define SPR_GQR0   912
+#define SPR_GQR1   913
+#define SPR_GQR2   914
+#define SPR_GQR3   915
+#define SPR_GQR4   916
+#define SPR_GQR5   917
+#define SPR_GQR6   918
+#define SPR_GQR7   919
+#define SPR_HID2   920
+#define SPR_WPAR   921
+#define SPR_DMA_U  922
+#define SPR_DMA_L  923
+#define SPR_UMMCR0 936
+#define SPR_UPMC1  937
+#define SPR_UPMC2  938
+#define SPR_USIA   939
+#define SPR_UMMCR1 940
+#define SPR_UPMC3  941
+#define SPR_UPMC4  942
+#define SPR_USDA   943
+#define SPR_MMCR0  952
+#define SPR_PMC1   953
+#define SPR_PMC2   954
+#define SPR_SIA    955
+#define SPR_MMCR1  956
+#define SPR_PMC3   957
+#define SPR_PMC4   958
+#define SPR_SDA    959
+#define SPR_HID0   1008
+#define SPR_HID1   1009
+#define SPR_IABR   1010
+#define SPR_HID4   1011
+#define SPR_DABR   1013
+#define SPR_L2CR   1017
+#define SPR_ICTC   1019
+#define SPR_THRM1  1020
+#define SPR_THRM2  1021
+#define SPR_FPECR  1022
+
+// PPC exceptions
+// 0x000 is reserved
+#define PPC_SystemReset             0x100
+#define PPC_MachineCheck            0x200
+#define PPC_DataStorage             0x300
+#define PPC_InstructionStorage      0x400
+#define PPC_ExternalInterrupt       0x500
+#define PPC_Alignment               0x600
+#define PPC_Program                 0x700
+#define PPC_FloatingPointUnavaiable 0x800
+#define PPC_Decrementer             0x900
+// 0xA00-0xB00 are reserved
+#define PPC_SystemCall          0xC00
+#define PPC_Trace               0xD00
+#define PPC_FloatingPointAssist 0xE00 // unimplemented in 750CL
+#define PPC_PerformanceMonitor  0xF00 // Dolphin/Broadway specific
+// 0x1000-0x1200 are unimplemented in 750CL
+#define PPC_InstructionAddressBreakpoint 0x1300 // Dolphin/Broadway specific
+// 0x1400-0x2F00 are reserved, but TRK uses some
+#define PPC_SystemManagementInterrupt 0x1400
+// 0x1500-0x1600 are unimplemented in 750CL
+#define PPC_ThermalManagementInterrupt 0x1700
+#define PPC_1800Exception              0x1800
+#define PPC_1900Exception              0x1900
+#define PPC_1A00Exception              0x1A00
+#define PPC_1B00Exception              0x1B00
+#define PPC_1C00Exception              0x1C00 // Data breakpoint?
+#define PPC_1D00Exception              0x1D00 // Instruction breakpoint?
+#define PPC_1E00Exception              0x1E00 // Peripheral breakpoint?
+#define PPC_1F00Exception              0x1F00 // Non maskable development port?
+#define PPC_2000Exception              0x2000
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __METROTRK_TRK_H__ */

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/FILE_POS.h

@@ -0,0 +1,18 @@
+#ifndef _MSL_COMMON_FILE_POS_H
+#define _MSL_COMMON_FILE_POS_H
+
+#include "ansi_files.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int fseek(FILE* file, unsigned long offset, int mode);
+int _fseek(FILE* file, fpos_t offset, int mode);
+long ftell(FILE* file);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _MSL_COMMON_FILE_POS_H */

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/abort_exit.h

@@ -0,0 +1,17 @@
+#ifndef _MSL_COMMON_ABORT_EXIT_H
+#define _MSL_COMMON_ABORT_EXIT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void exit(int status);
+void abort(void);
+
+extern void (*__stdio_exit)(void);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif /* _MSL_COMMON_ABORT_EXIT_H */

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/alloc.h

@@ -0,0 +1,16 @@
+#ifndef _MSL_COMMON_ALLOC_H
+#define _MSL_COMMON_ALLOC_H
+
+#include "ansi_files.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void free(void* ptr);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _MSL_COMMON_ALLOC_H */

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/ansi_files.h

@@ -0,0 +1,133 @@
+#ifndef _MSL_COMMON_ANSI_FILES_H
+#define _MSL_COMMON_ANSI_FILES_H
+
+#include "stddef.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SEEK_SET 0
+#define SEEK_CUR 1
+#define SEEK_END 2
+
+typedef unsigned long __file_handle;
+typedef unsigned long fpos_t;
+#ifndef __cplusplus
+typedef unsigned short wchar_t;
+#endif
+
+#define set_error(file)                                                        \
+	do {                                                                       \
+		(file)->file_state.error = 1;                                          \
+		(file)->buffer_length    = 0;                                          \
+	} while (0)
+
+enum __file_kinds {
+	__closed_file,
+	__disk_file,
+	__console_file,
+	__string_file,
+	__unavailable_file,
+};
+
+enum __file_orientation {
+	/* 0x0 */ UNORIENTED,
+	/* 0x1 */ CHAR_ORIENTED,
+	/* 0x2 */ WIDE_ORIENTED,
+};
+
+typedef struct _file_modes {
+	unsigned int open_mode : 2;
+	unsigned int io_mode : 3;
+	unsigned int buffer_mode : 2;
+	unsigned int file_kind : 3;
+	unsigned int file_orientation : 2;
+	unsigned int binary_io : 1;
+} file_modes;
+
+enum __io_modes {
+	__read       = 1,
+	__write      = 2,
+	__read_write = 3,
+	__append     = 4,
+};
+
+enum __io_states {
+	__neutral,
+	__writing,
+	__reading,
+	__rereading,
+};
+
+enum __io_results {
+	__no_io_error,
+	__io_error,
+	__io_EOF,
+};
+
+typedef struct _file_states {
+	unsigned int io_state : 3;
+	unsigned int free_buffer : 1;
+	unsigned char eof;
+	unsigned char error;
+} file_states;
+
+typedef void (*__idle_proc)(void);
+typedef int (*__pos_proc)(__file_handle file, fpos_t* position, int mode,
+                          __idle_proc idle_proc);
+typedef int (*__io_proc)(__file_handle file, unsigned char* buff, size_t* count,
+                         __idle_proc idle_proc);
+typedef int (*__close_proc)(__file_handle file);
+
+typedef struct _FILE {
+	__file_handle handle;
+	file_modes file_mode;
+	file_states file_state;
+
+	char char_buffer;
+	char char_buffer_overflow;
+	char ungetc_buffer[2];
+	wchar_t ungetc_wide_buffer[2];
+
+	unsigned long position;
+	unsigned char* buffer;
+	unsigned long buffer_size;
+	unsigned char* buffer_ptr;
+	unsigned long buffer_length;
+	unsigned long buffer_alignment;
+	unsigned long save_buffer_length;
+	unsigned long buffer_position;
+
+	__pos_proc position_fn;
+	__io_proc read_fn;
+	__io_proc write_fn;
+	__close_proc close_fn;
+	__idle_proc idle_fn;
+} FILE;
+
+typedef struct _files {
+	FILE _stdin;
+	FILE _stdout;
+	FILE _stderr;
+} files;
+
+#define _IONBF 0
+#define _IOLBF 1
+#define _IOFBF 2
+
+extern files __files;
+extern int __close_console(__file_handle file);
+extern int __write_console(__file_handle file, unsigned char* buf,
+                           size_t* count, __idle_proc idle_fn);
+extern int __read_console(__file_handle file, unsigned char* buf, size_t* count,
+                          __idle_proc idle_fn);
+
+unsigned int __flush_all(void);
+void __close_all(void);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif /* _MSL_COMMON_ANSI_FILES_H */

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/ansi_fp.h

@@ -0,0 +1,36 @@
+#ifndef _MSL_COMMON_ANSI_FP_H
+#define _MSL_COMMON_ANSI_FP_H
+
+#include "float.h"
+
+#define SIGDIGLEN 36
+
+typedef struct decimal {
+	char sign;
+	char unk1;
+	short exp;
+	struct {
+		unsigned char length;
+		unsigned char text[36];
+		unsigned char unk41;
+	} sig;
+} decimal;
+
+typedef struct decform {
+	char style;
+	char unk1;
+	short digits;
+} decform;
+
+/* void __ull2dec(decimal*, u64);
+void __timesdec(decimal*, const decimal*, const decimal*);
+void __str2dec(decimal*, const char*, short);
+void __two_exp(decimal*, s16);
+BOOL __equals_dec(const decimal*, const decimal*);
+BOOL __less_dec(const decimal*, const decimal*);
+void __minus_dec(decimal*, const decimal*, const decimal*);
+void __num2dec_internal(decimal*, f64);
+void __num2dec(const decform*, f64, decimal*);
+f64 __dec2num(const decimal*); */
+
+#endif

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/arith.h

@@ -0,0 +1,19 @@
+#ifndef _MSL_COMMON_ARITH_H
+#define _MSL_COMMON_ARITH_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+	int quot; /* quotient */
+	int rem;  /* remainder */
+} div_t;
+
+div_t div(int numerator, int denominator);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _MSL_COMMON_ARITH_H */

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/buffer_io.h

@@ -0,0 +1,11 @@
+#ifndef _MSL_COMMON_BUFFER_IO_H
+#define _MSL_COMMON_BUFFER_IO_H
+
+#include "ansi_files.h"
+
+enum { __align_buffer, __dont_align_buffer };
+
+void __prep_buffer(FILE* file);
+int __flush_buffer(FILE* file, size_t* bytes_flushed);
+
+#endif /* _MSL_COMMON_BUFFER_IO_H */

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/char_io.h

@@ -0,0 +1,17 @@
+#ifndef _MSL_COMMON_CHAR_IO_H
+#define _MSL_COMMON_CHAR_IO_H
+
+#include "ansi_files.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int fputs(const char* str, FILE* stream);
+int __put_char(int c, FILE* stream);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _MSL_COMMON_CHAR_IO_H */

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/critical_regions.h

@@ -0,0 +1,30 @@
+#ifndef _MSL_COMMON_CRITICAL_REGIONS_H
+#define _MSL_COMMON_CRITICAL_REGIONS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum critical_regions {
+	atexit_funcs_access,
+	malloc_pool_access,
+	stdin_access,
+	stdout_access,
+	stderr_access,
+	files_access,
+	console_status_access,
+	signal_funcs_access,
+	thread_access,
+	num_critical_regions
+};
+
+void __init_critical_regions(void);
+void __kill_critical_regions(void);
+void __begin_critical_region(int region);
+void __end_critical_region(int region);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/ctype.h

@@ -0,0 +1,76 @@
+#ifndef _MSL_COMMON_CTYPE_H
+#define _MSL_COMMON_CTYPE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define EOF -1L
+
+extern const unsigned char __ctype_map[];
+extern const unsigned char __lower_map[];
+extern const unsigned char __upper_map[];
+
+#define __control_char 0x01
+#define __motion_char  0x02
+#define __space_char   0x04
+#define __punctuation  0x08
+#define __digit        0x10
+#define __hex_digit    0x20
+#define __lower_case   0x40
+#define __upper_case   0x80
+
+#define __letter       (__lower_case | __upper_case)
+#define __alphanumeric (__letter | __digit)
+#define __graphic      (__alphanumeric | __punctuation)
+#define __printable    (__graphic | __space_char)
+#define __whitespace   (__motion_char | __space_char)
+#define __control      (__motion_char | __control_char)
+#define __zero_fill(c) ((int)(unsigned char)(c))
+
+int tolower(int c);
+int toupper(int c);
+
+inline int isalpha(int c)
+{
+	return (int)(__ctype_map[(unsigned char)c] & __letter);
+}
+inline int isdigit(int c)
+{
+	return (int)(__ctype_map[(unsigned char)c] & __digit);
+}
+inline int isspace(int c)
+{
+	return (int)(__ctype_map[(unsigned char)c] & __whitespace);
+}
+inline int isupper(int c)
+{
+	return (int)(__ctype_map[(unsigned char)c] & __upper_case);
+}
+inline int isxdigit(int c)
+{
+	return (int)(__ctype_map[(unsigned char)c] & __hex_digit);
+}
+
+inline int _tolower(int c)
+{
+	return (c == -1 ? -1 : (int)__lower_map[(unsigned char)c]);
+}
+
+#ifdef __cplusplus
+};
+
+namespace std {
+inline int tolower(int c)
+{
+	return (c == -1 ? -1 : (int)__lower_map[(unsigned char)c]);
+}
+inline int toupper(int c)
+{
+	return (c == -1 ? -1 : (int)__upper_map[(unsigned char)c]);
+}
+}; // namespace std
+
+#endif
+
+#endif /* _MSL_COMMON_CTYPE_H */

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/direct_io.h

@@ -0,0 +1,17 @@
+#ifndef _MSL_COMMON_DIRECT_IO_H
+#define _MSL_COMMON_DIRECT_IO_H
+
+#include "ansi_files.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+size_t __fwrite(const void* buffer, size_t size, size_t count, FILE* stream);
+size_t fwrite(const void* buffer, size_t size, size_t count, FILE* stream);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _MSL_COMMON_DIRECT_IO_H */

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/errno.h

@@ -0,0 +1,20 @@
+#ifndef MSL_COMMON_SRC_ERRNO_H
+#define MSL_COMMON_SRC_ERRNO_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ENOERR   0
+#define EDOM     33
+#define ERANGE   34
+#define EFPOS    40
+#define ESIGPARM 36
+
+extern int errno;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MSL_COMMON_SRC_ERRNO_H */

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/extras.h

@@ -0,0 +1,15 @@
+#ifndef _MSL_COMMON_EXTRAS_H
+#define _MSL_COMMON_EXTRAS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int strnicmp(const char* str1, const char* str2, int n);
+int stricmp(const char* str1, const char* str2);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _MSL_COMMON_EXTRAS_H */

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/file_io.h

@@ -0,0 +1,18 @@
+#ifndef _MSL_COMMON_FILE_IO_H
+#define _MSL_COMMON_FILE_IO_H
+
+#include "ansi_files.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int __msl_strnicmp(const char* str1, const char* str2, int n);
+int fflush(FILE* file);
+int fclose(FILE* file);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _MSL_COMMON_FILE_IO_H */

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/float.h

@@ -0,0 +1,92 @@
+#ifndef _MSL_COMMON_FLOAT_H
+#define _MSL_COMMON_FLOAT_H
+
+#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common_Embedded/Math/fdlibm.h"
+
+#define FP_SNAN      0
+#define FP_QNAN      1
+#define FP_INFINITE  2
+#define FP_ZERO      3
+#define FP_NORMAL    4
+#define FP_SUBNORMAL 5
+
+#define FP_NAN FP_QNAN
+
+#define fpclassify(x)                                                          \
+	((sizeof(x) == sizeof(float)) ? __fpclassifyf(x) : __fpclassifyd(x))
+#define signbit(x)                                                             \
+	((sizeof(x) == sizeof(float)) ? __signbitf(x) : __signbitd(x))
+#define isfinite(x) ((fpclassify(x) > 2))
+#define isnan(x)    ((fpclassify(x) == FP_NAN))
+#define isinf(x)    ((fpclassify(x) == FP_INFINITE))
+
+#define __signbitf(x) ((int)(__HI(x) & 0x80000000))
+
+// TODO: OK?
+#define __signbitd(x) ((int)(__HI(x) & 0x80000000))
+
+extern unsigned long __float_nan[];
+extern unsigned long __float_huge[];
+extern unsigned long __float_max[];
+extern unsigned long __float_epsilon[];
+
+inline int __fpclassifyf(float __value)
+{
+	unsigned long integer = *(unsigned long*)&__value;
+
+	switch (integer & 0x7f800000) {
+	case 0x7f800000:
+		if ((integer & 0x7fffff) != 0) {
+			return FP_QNAN;
+		}
+		return FP_INFINITE;
+
+	case 0:
+		if ((integer & 0x7fffff) != 0) {
+			return FP_SUBNORMAL;
+		}
+		return FP_ZERO;
+	}
+
+	return FP_NORMAL;
+}
+
+inline int __fpclassifyd(double __value)
+{
+	switch (__HI(__value) & 0x7ff00000) {
+	case 0x7ff00000: {
+		if ((__HI(__value) & 0x000fffff) || (__LO(__value) & 0xffffffff))
+			return FP_QNAN;
+		else
+			return FP_INFINITE;
+		break;
+	}
+	case 0: {
+		if ((__HI(__value) & 0x000fffff) || (__LO(__value) & 0xffffffff))
+			return FP_SUBNORMAL;
+		else
+			return FP_ZERO;
+		break;
+	}
+	}
+	return FP_NORMAL;
+}
+
+#define FLT_MANT_DIG   24
+#define FLT_DIG        6
+#define FLT_MIN_EXP    (-125)
+#define FLT_MIN_10_EXP (-37)
+#define FLT_MAX_EXP    128
+#define FLT_MAX_10_EXP 38
+
+#define FLT_MAX     3.40282346638528860e+38f
+#define FLT_EPSILON 1.1920928955078125e-07f
+
+#define DBL_MANT_DIG   53
+#define DBL_DIG        15
+#define DBL_MIN_EXP    (-1021)
+#define DBL_MIN_10_EXP (-308)
+#define DBL_MAX_EXP    1024
+#define DBL_MAX_10_EXP 308
+
+#endif /* _MSL_COMMON_FLOAT_H */

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/limits.h

@@ -0,0 +1,93 @@
+#ifndef _STD_LIMITS_H
+#define _STD_LIMITS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CHAR_BIT 8
+
+#define SCHAR_MIN (-0x7F - 1)
+#define SCHAR_MAX 0x7F
+#define UCHAR_MAX 0xFF
+
+#define CHAR_MIN 0
+#define CHAR_MAX SCHAR_MAX
+
+#define SHRT_MIN  (-0x7FFF - 1)
+#define SHRT_MAX  0x7FFF
+#define USHRT_MAX 0xFFFF
+
+#define INT_MIN  (-0x7FFFFFFF - 1)
+#define INT_MAX  0x7FFFFFFF
+#define UINT_MAX 0xFFFFFFFF
+
+#define LONG_MIN  (-0x7FFFFFFFL - 1)
+#define LONG_MAX  0x7FFFFFFFL
+#define ULONG_MAX 0xFFFFFFFFUL
+
+#define LLONG_MIN  (-0x7FFFFFFFFFFFFFFFLL - 1)
+#define LLONG_MAX  0x7FFFFFFFFFFFFFFFLL
+#define ULLONG_MAX 0xFFFFFFFFFFFFFFFFULL
+
+#ifdef __cplusplus
+}
+
+namespace std {
+template <typename T> class numeric_limits {
+public:
+	inline static T min();
+	inline static T max();
+};
+
+template <> class numeric_limits<char> {
+public:
+	inline static char min() { return -0x80; }
+	inline static char max() { return 0x7F; }
+};
+
+template <> class numeric_limits<short> {
+public:
+	inline static short min() { return -0x8000; }
+	inline static short max() { return 0x7FFF; }
+};
+
+template <> class numeric_limits<int> {
+public:
+	inline static int min() { return -0x80000000; }
+	inline static int max() { return 0x7FFFFFFF; }
+};
+
+template <> class numeric_limits<long> {
+public:
+	inline static long min() { return -0x80000000; }
+	inline static long max() { return 0x7FFFFFFF; }
+};
+
+template <> class numeric_limits<unsigned char> {
+public:
+	inline static unsigned char min() { return 0x0; }
+	inline static unsigned char max() { return 0xFF; }
+};
+
+template <> class numeric_limits<unsigned short> {
+public:
+	inline static unsigned short min() { return 0x0; }
+	inline static unsigned short max() { return 0xFFFF; }
+};
+
+template <> class numeric_limits<unsigned int> {
+public:
+	inline static unsigned int min() { return 0x0; }
+	inline static unsigned int max() { return 0xFFFFFFFF; }
+};
+
+template <> class numeric_limits<unsigned long> {
+public:
+	inline static unsigned long min() { return 0x0; }
+	inline static unsigned long max() { return 0xFFFFFFFF; }
+};
+
+} // namespace std
+#endif
+#endif

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/math.h

@@ -0,0 +1,106 @@
+#ifndef MSL_MATH_H_
+#define MSL_MATH_H_
+
+#include "float.h"
+
+#define NAN       (*(float*)__float_nan)
+#define HUGE_VALF (*(float*)__float_huge)
+
+#define M_PI    3.14159265358979323846f
+#define M_SQRT3 1.73205f
+
+#define DEG_TO_RAD(degrees) (degrees * (M_PI / 180.0f))
+#define RAD_TO_DEG(radians)                                                    \
+	(radians                                                                   \
+	 * (180.0f / M_PI + 0.000005f)) // the 0.000005f is probably a fakematch
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int abs(int);
+double acos(double);
+float acosf(float);
+double asin(double);
+double atan(double);
+double atan2(double, double);
+double ceil(double);
+double copysign(double, double);
+double cos(double);
+float cosf(float);
+double exp(double);
+
+extern double __fabs(double);
+extern float __fabsf(float);
+inline double fabs(double f) { return __fabs(f); }
+
+double __frsqrte(double);
+float __fres(float);
+
+double floor(double);
+double fmod(double, double);
+
+double frexp(double, int*);
+double ldexp(double, int);
+double modf(double, double*);
+double pow(double, double);
+double sin(double);
+float sinf(float);
+double tan(double);
+float tanf(float);
+
+extern inline double sqrt(double x)
+{
+	if (x > 0.0) {
+		double guess = __frsqrte(x); /* returns an approximation to    */
+		guess
+		    = .5 * guess * (3.0 - guess * guess * x); /* now have 8 sig bits */
+		guess
+		    = .5 * guess * (3.0 - guess * guess * x); /* now have 16 sig bits */
+		guess
+		    = .5 * guess * (3.0 - guess * guess * x); /* now have 32 sig bits */
+		guess = .5 * guess
+		        * (3.0 - guess * guess * x); /* now have > 53 sig bits        */
+		return x * guess;
+	} else if (x == 0)
+		return 0;
+	else if (x)
+		return NAN;
+
+	return HUGE_VALF;
+}
+
+#ifdef __cplusplus
+};
+
+namespace std {
+inline float fabsf(float f) { return fabs(f); }
+inline float abs(float f) { return fabsf(f); }
+inline float fmodf(float x, float y) { return fmod(x, y); }
+inline float atan2f(float y, float x) { return (float)atan2(y, x); }
+inline float sinf(float x) { return sin(x); }
+inline float cosf(float x) { return cos(x); }
+inline float tanf(float x) { return tan(x); }
+
+extern inline float sqrtf(float x)
+{
+	const double _half  = .5;
+	const double _three = 3.0;
+	volatile float y;
+	if (x > 0.0f) {
+		double guess = __frsqrte((double)x); // returns an approximation to
+		guess        = _half * guess
+		        * (_three - guess * guess * x); // now have 12 sig bits
+		guess = _half * guess
+		        * (_three - guess * guess * x); // now have 24 sig bits
+		guess = _half * guess
+		        * (_three - guess * guess * x); // now have 32 sig bits
+		y = (float)(x * guess);
+		return y;
+	}
+	return x;
+}
+}; // namespace std
+#endif
+
+#endif

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/mbstring.h

@@ -0,0 +1,16 @@
+#ifndef _MSL_COMMON_MBSTRING_H
+#define _MSL_COMMON_MBSTRING_H
+
+#include "wchar_io.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+size_t wcstombs(char* dst, const wchar_t* src, size_t n);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _MSL_COMMON_MBSTRING_H */

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/mem_funcs.h

@@ -0,0 +1,19 @@
+#ifndef _MSL_COMMON_MEM_FUNCS_H
+#define _MSL_COMMON_MEM_FUNCS_H
+
+#include "stddef.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void __copy_longs_rev_unaligned(void* dst, const void* src, size_t n);
+void __copy_longs_unaligned(void* dst, const void* src, size_t n);
+void __copy_longs_rev_aligned(void* dst, const void* src, size_t n);
+void __copy_longs_aligned(void* dst, const void* src, size_t n);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _MSL_COMMON_MEM_FUNCS_H */

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/misc_io.h

@@ -0,0 +1,14 @@
+#ifndef _MSL_COMMON_MISC_IO_H
+#define _MSL_COMMON_MISC_IO_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void __stdio_atexit(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _MSL_COMMON_MISC_IO_H */

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/printf.h

@@ -0,0 +1,22 @@
+#ifndef _MSL_COMMON_PRINTF_H
+#define _MSL_COMMON_PRINTF_H
+
+#include "ansi_files.h"
+#include "stdarg.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int fprintf(FILE* stream, const char* format, ...);
+int printf(const char* format, ...);
+int sprintf(char* s, const char* format, ...);
+int snprintf(char* s, size_t n, const char* format, ...);
+int vsnprintf(char* s, size_t n, const char* format, va_list arg);
+int vprintf(const char* format, va_list arg);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _MSL_COMMON_PRINTF_H */

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/scanf.h

@@ -0,0 +1,43 @@
+#ifndef _MSL_COMMON_SCANF_H
+#define _MSL_COMMON_SCANF_H
+
+#include "stddef.h"
+#include "ansi_files.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum __ReadProcActions { __GetAChar, __UngetAChar, __TestForError };
+
+enum __WReadProcActions { __GetAwChar, __UngetAwChar, __TestForwcsError };
+
+typedef struct {
+	char* CharStr;
+	size_t MaxCharCount;
+	size_t CharsWritten;
+} __OutStrCtrl;
+
+typedef struct {
+	char* NextChar;
+	int NullCharDetected;
+} __InStrCtrl;
+
+typedef struct {
+	wchar_t* wCharStr;
+	size_t MaxCharCount;
+	size_t CharsWritten;
+} __wOutStrCtrl;
+
+typedef struct {
+	wchar_t* wNextChar;
+	int wNullCharDetected;
+} __wInStrCtrl;
+
+int __StringRead(void* str, int ch, int behavior);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _MSL_COMMON_SCANF_H */

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/signal.h

@@ -0,0 +1,16 @@
+#ifndef _MSL_COMMON_SIGNAL_H
+#define _MSL_COMMON_SIGNAL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*__signal_func_ptr)(int);
+
+int raise(int sig);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _MSL_COMMON_SIGNAL_H */

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/stdarg.h

@@ -0,0 +1,39 @@
+#ifndef _MSL_COMMON_STDARG_H
+#define _MSL_COMMON_STDARG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __MWERKS__
+typedef struct {
+	char gpr;
+	char fpr;
+	char reserved[2];
+	char* input_arg_area;
+	char* reg_save_area;
+} __va_list[1];
+typedef __va_list va_list;
+
+#ifndef __MWERKS__
+extern void __builtin_va_info(va_list*);
+#endif
+
+void* __va_arg(va_list v_list, unsigned char type);
+
+#define va_start(ap, fmt) ((void)fmt, __builtin_va_info(&ap))
+#define va_arg(ap, t)     (*((t*)__va_arg(ap, _var_arg_typeof(t))))
+#define va_end(ap)        (void)0
+
+#else
+typedef __builtin_va_list va_list;
+#define va_start(v, l) __builtin_va_start(v, l)
+#define va_end(v)      __builtin_va_end(v)
+#define va_arg(v, l)   __builtin_va_arg(v, l)
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _MSL_COMMON_STDARG_H */

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/stddef.h

@@ -0,0 +1,26 @@
+#ifndef _STDDEF_H_
+#define _STDDEF_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __INTELLISENSE__
+typedef unsigned int size_t;
+typedef int ptrdiff_t;
+#else
+typedef unsigned long size_t;
+typedef long ptrdiff_t;
+#endif
+
+#define offsetof(type, member) ((size_t) & (((type*)0)->member))
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/stdio.h

@@ -0,0 +1,13 @@
+#ifndef MSL_STDIO_H_
+#define MSL_STDIO_H_
+
+#include "char_io.h" // IWYU pragma: export
+#include "file_io.h" // IWYU pragma: export
+#include "printf.h"  // IWYU pragma: export
+#include "extras.h"  // IWYU pragma: export
+
+#define stdin  (&__files._stdin)
+#define stdout (&__files._stdout)
+#define stderr (&__files._stderr)
+
+#endif

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/stdlib.h

@@ -0,0 +1,9 @@
+#ifndef MSL_STDLIB_H_
+#define MSL_STDLIB_H_
+
+#include "abort_exit.h"
+#include "arith.h"
+#include "mbstring.h"
+#include "strtoul.h"
+
+#endif

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/string.h

@@ -0,0 +1,36 @@
+#ifndef _MSL_COMMON_STRING_H
+#define _MSL_COMMON_STRING_H
+
+#include "stddef.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+__declspec(section ".init") void* memcpy(void* dest, const void* src, size_t n);
+__declspec(section ".init") void __fill_mem(void* dest, int val, size_t count);
+__declspec(section ".init") void* memset(void* dest, int val, size_t count);
+
+int memcmp(const void* lhs, const void* rhs, size_t count);
+void* __memrchr(const void* ptr, int ch, size_t count);
+void* memchr(const void* ptr, int ch, size_t count);
+void* memmove(void* dst, const void* src, size_t n);
+char* strrchr(const char* str, int c);
+char* strchr(const char* str, int c);
+int strncmp(const char* str1, const char* str2, size_t n);
+int strcmp(const char* str1, const char* str2);
+char* strcat(char* dst, const char* src);
+char* strncpy(char* dst, const char* src, size_t n);
+char* strcpy(char* dst, const char* src);
+size_t strlen(const char* str);
+
+#ifdef __cplusplus
+};
+
+namespace std {
+using ::strlen;
+using ::strrchr;
+}; // namespace std
+#endif
+
+#endif /* _MSL_COMMON_STRING_H */

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/strtoul.h

@@ -0,0 +1,18 @@
+#ifndef _MSL_COMMON_STRTOUL_H
+#define _MSL_COMMON_STRTOUL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+long strtol(const char* str, char** end, int base);
+unsigned long strtoul(const char* str, char** end, int base);
+unsigned long __strtoul(int base, int max_width,
+                        int (*ReadProc)(void*, int, int), void* ReadProcArg,
+                        int* chars_scanned, int* negative, int* overflow);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _MSL_COMMON_STRTOUL_H */

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/wchar_io.h

@@ -0,0 +1,12 @@
+#ifndef _MSL_COMMON_WCHAR_IO_H
+#define _MSL_COMMON_WCHAR_IO_H
+
+#include "ansi_files.h"
+
+#ifndef __cplusplus
+typedef unsigned short wchar_t;
+#endif
+
+int fwide(FILE* file, int mode);
+
+#endif /* _MSL_COMMON_WCHAR_IO_H */

include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common_Embedded/Math/fdlibm.h

@@ -0,0 +1,234 @@
+#ifndef _FDLIBM_H
+#define _FDLIBM_H
+
+/* @(#)fdlibm.h 1.5 04/04/22 */
+/**
+ * ====================================================
+ * Copyright (C) 2004 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif // ifdef __cplusplus
+
+/* Sometimes it's necessary to define __LITTLE_ENDIAN explicitly
+   but these catch some common cases. */
+
+#if defined(i386) || defined(i486) || defined(intel) || defined(x86)           \
+    || defined(i86pc) || defined(__alpha) || defined(__osf__)
+#define __LITTLE_ENDIAN
+#endif
+
+#ifdef __LITTLE_ENDIAN
+#define __HI(x)  *(1 + (int*)&x)
+#define __LO(x)  *(int*)&x
+#define __HIp(x) *(1 + (int*)x)
+#define __LOp(x) *(int*)x
+#else
+#define __HI(x)  *(int*)&x
+#define __LO(x)  *(1 + (int*)&x)
+#define __HIp(x) *(int*)x
+#define __LOp(x) *(1 + (int*)x)
+#endif
+
+// NOTE: should be enabled according to w_atan2.c
+#define _IEEE_LIBM
+
+// TODO: should __STDC__ actually be defined?
+// #ifdef __STDC__
+#define __P(p) p
+// #else
+// #define __P(p) ()
+// #endif
+
+/**
+ * ANSI/POSIX
+ */
+
+extern int signgam;
+
+#define MAXFLOAT ((f32)3.40282346638528860e+38)
+
+enum fdversion { fdlibm_ieee = -1, fdlibm_svid, fdlibm_xopen, fdlibm_posix };
+
+#define _LIB_VERSION_TYPE enum fdversion
+#define _LIB_VERSION      _fdlib_version
+
+/* if global variable _LIB_VERSION is not desirable, one may
+ * change the following to be a constant by:
+ *	#define _LIB_VERSION_TYPE const enum version
+ * In that case, after one initializes the value _LIB_VERSION (see
+ * s_lib_version.c) during compile time, it cannot be modified
+ * in the middle of a program
+ */
+extern _LIB_VERSION_TYPE _LIB_VERSION;
+
+#define _IEEE_  fdlibm_ieee
+#define _SVID_  fdlibm_svid
+#define _XOPEN_ fdlibm_xopen
+#define _POSIX_ fdlibm_posix
+
+struct exception {
+	int type;
+	char* name;
+	double arg1;
+	double arg2;
+	double retval;
+};
+
+#define HUGE MAXFLOAT
+
+/**
+ * set X_TLOSS = pi*2**52, which is possibly defined in <values.h>
+ * (one may replace the following line by "#include <values.h>")
+ */
+
+#define X_TLOSS 1.41484755040568800000e+16
+
+#define DOMAIN    1
+#define SING      2
+#define OVERFLOW  3
+#define UNDERFLOW 4
+#define TLOSS     5
+#define PLOSS     6
+
+/**
+ * ANSI/POSIX
+ */
+extern double acos __P((double));
+extern double asin __P((double));
+extern double atan __P((double));
+extern double atan2 __P((double, double));
+extern double cos __P((double));
+extern double sin __P((double));
+extern double tan __P((double));
+
+extern double cosh __P((double));
+extern double sinh __P((double));
+extern double tanh __P((double));
+
+extern double exp __P((double));
+extern double frexp __P((double, int*));
+extern double ldexp __P((double, int));
+extern double scalbn __P((double, int));
+extern double log __P((double));
+extern double log10 __P((double));
+extern double modf __P((double, double*));
+
+extern double pow __P((double, double));
+extern double sqrt __P((double));
+
+extern double ceil __P((double));
+extern double fabs __P((double));
+// NOTE: I have no idea how they got it to mangle like this
+extern double fabs__Fd(double);
+extern double floor __P((double));
+extern double fmod __P((double, double));
+
+extern double erf __P((double));
+extern double erfc __P((double));
+extern double gamma __P((double));
+extern double hypot __P((double, double));
+extern int isnan __P((double));
+extern int finite __P((double));
+extern double j0 __P((double));
+extern double j1 __P((double));
+extern double jn __P((int, double));
+extern double lgamma __P((double));
+extern double y0 __P((double));
+extern double y1 __P((double));
+extern double yn __P((int, double));
+
+extern double acosh __P((double));
+extern double asinh __P((double));
+extern double atanh __P((double));
+extern double cbrt __P((double));
+extern double logb __P((double));
+extern double nextafter __P((double, double));
+extern double remainder __P((double, double));
+#ifdef _SCALB_INT
+extern double scalb __P((double, int));
+#else
+extern double scalb __P((double, double));
+#endif
+
+extern int matherr __P((struct exception*));
+
+/**
+ * IEEE Test Vector
+ */
+extern double significand __P((double));
+
+/**
+ * Functions callable from C, intended to support IEEE arithmetic.
+ */
+extern double copysign __P((double, double));
+extern int ilogb __P((double));
+extern double rint __P((double));
+extern double scalbn __P((double, int));
+
+/**
+ * BSD math library entry points
+ */
+extern double expm1 __P((double));
+extern double log1p __P((double));
+
+/**
+ * Reentrant version of gamma & lgamma; passes signgam back by reference
+ * as the second argument; user must allocate space for signgam.
+ */
+#ifdef _REENTRANT
+extern double gamma_r __P((double, int*));
+extern double lgamma_r __P((double, int*));
+#endif /* _REENTRANT */
+
+/* ieee style elementary functions */
+extern double __ieee754_sqrt __P((double));
+extern double __ieee754_acos __P((double));
+extern double __ieee754_acosh __P((double));
+extern double __ieee754_log __P((double));
+extern double __ieee754_atanh __P((double));
+extern double __ieee754_asin __P((double));
+extern double __ieee754_atan2 __P((double, double));
+extern double __ieee754_exp __P((double));
+extern double __ieee754_cosh __P((double));
+extern double __ieee754_fmod __P((double, double));
+extern double __ieee754_pow __P((double, double));
+extern double __ieee754_lgamma_r __P((double, int*));
+extern double __ieee754_gamma_r __P((double, int*));
+extern double __ieee754_lgamma __P((double));
+extern double __ieee754_gamma __P((double));
+extern double __ieee754_log10 __P((double));
+extern double __ieee754_sinh __P((double));
+extern double __ieee754_hypot __P((double, double));
+extern double __ieee754_j0 __P((double));
+extern double __ieee754_j1 __P((double));
+extern double __ieee754_y0 __P((double));
+extern double __ieee754_y1 __P((double));
+extern double __ieee754_jn __P((int, double));
+extern double __ieee754_yn __P((int, double));
+extern double __ieee754_remainder __P((double, double));
+extern int __ieee754_rem_pio2 __P((double, double*));
+#ifdef _SCALB_INT
+extern double __ieee754_scalb __P((double, int));
+#else
+extern double __ieee754_scalb __P((double, double));
+#endif
+
+/* fdlibm kernel function */
+extern double __kernel_standard __P((double, double, int));
+extern double __kernel_sin __P((double, double, int));
+extern double __kernel_cos __P((double, double));
+extern double __kernel_tan __P((double, double, int));
+extern int __kernel_rem_pio2 __P((double*, double*, int, int, int, const int*));
+
+#ifdef __cplusplus
+};
+#endif // ifdef __cplusplus
+
+#endif

include/PowerPC_EABI_Support/Runtime/MWCPlusLib.h

@@ -0,0 +1,44 @@
+#ifndef _RUNTIME_MWCPLUSLIB_H
+#define _RUNTIME_MWCPLUSLIB_H
+
+#include "stddef.h"
+
+#define CTORARG_TYPE     int
+#define CTORARG_PARTIAL  (0)
+#define CTORARG_COMPLETE (1)
+
+#define CTORCALL_COMPLETE(ctor, objptr)                                        \
+	(((void (*)(void*, CTORARG_TYPE))ctor)(objptr, CTORARG_COMPLETE))
+
+#define DTORARG_TYPE int
+
+#define DTORCALL_COMPLETE(dtor, objptr)                                        \
+	(((void (*)(void*, DTORARG_TYPE))dtor)(objptr, -1))
+#define DTORCALL_PARTIAL(dtor, objptr)                                         \
+	(((void (*)(void*, DTORARG_TYPE))dtor)(objptr, 0))
+
+typedef void* ConstructorDestructor;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void* __copy(char* to, char* from, size_t size);
+
+extern void __construct_array(void* ptr, ConstructorDestructor ctor,
+                              ConstructorDestructor dtor, size_t size,
+                              size_t n);
+extern void __destroy_arr(void* block, ConstructorDestructor* dtor, size_t size,
+                          size_t n);
+extern void* __construct_new_array(void* block, ConstructorDestructor ctor,
+                                   ConstructorDestructor dtor_arg, size_t size,
+                                   size_t n);
+extern void __destroy_new_array(void* block, ConstructorDestructor dtor);
+extern void __destroy_new_array2();
+extern void __destroy_new_array3();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/PowerPC_EABI_Support/Runtime/NMWException.h

@@ -0,0 +1,43 @@
+#ifndef _NMWEXCEPTION
+#define _NMWEXCEPTION
+
+typedef short vbase_ctor_arg_type;
+typedef char local_cond_type;
+
+typedef struct CatchInfo {
+	void* location;
+	void* typeinfo;
+	void* dtor;
+	void* sublocation;
+	long pointercopy;
+	void* stacktop;
+} CatchInfo;
+
+typedef struct DestructorChain {
+	struct DestructorChain* next;
+	void* destructor;
+	void* object;
+} DestructorChain;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void* __register_global_object(void* object, void* destructor,
+                                      void* registration);
+extern void __destroy_global_chain(void);
+
+extern void __end__catch(CatchInfo* catchinfo);
+extern void __throw(char* throwtype, void* location, void* dtor);
+extern char __throw_catch_compare(const char* throwtype, const char* catchtype,
+                                  long* offset_result);
+extern void __unexpected(CatchInfo* catchinfo);
+
+extern int __register_fragment(struct __eti_init_info* info, char* TOC);
+extern void __unregister_fragment(int fragmentID);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _NMWEXCEPTION

include/PowerPC_EABI_Support/Runtime/__mem.h

@@ -0,0 +1,17 @@
+#ifndef _RUNTIME_MEM_H
+#define _RUNTIME_MEM_H
+
+#include "stddef.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+__declspec(section ".init") void* memcpy(void* dest, const void* src, size_t n);
+__declspec(section ".init") void* memset(void* dest, int val, size_t count);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/PowerPC_EABI_Support/Runtime/__ppc_eabi_linker.h

@@ -0,0 +1,72 @@
+#ifndef __PPC_EABI_LINKER
+#define __PPC_EABI_LINKER
+
+__declspec(section ".init") extern char _stack_addr[];
+__declspec(section ".init") extern char _stack_end[];
+__declspec(section ".init") extern char _heap_addr[];
+__declspec(section ".init") extern char _heap_end[];
+__declspec(section ".init") extern const char _fextabindex_rom[];
+__declspec(section ".init") extern char _fextabindex[];
+__declspec(section ".init") extern char _eextabindex[];
+
+__declspec(section ".init") extern char _SDA_BASE_[];
+
+__declspec(section ".init") extern char _SDA2_BASE_[];
+
+typedef struct __rom_copy_info {
+	char* rom;
+	char* addr;
+	unsigned int size;
+} __rom_copy_info;
+
+__declspec(section ".init") extern __rom_copy_info _rom_copy_info[];
+
+typedef struct __bss_init_info {
+	char* addr;
+	unsigned int size;
+} __bss_init_info;
+
+__declspec(section ".init") extern __bss_init_info _bss_init_info[];
+
+typedef struct __eti_init_info {
+	void* eti_start;
+	void* eti_end;
+	void* code_start;
+	unsigned long code_size;
+} __eti_init_info;
+
+__declspec(section ".init") extern __eti_init_info _eti_init_info[];
+__declspec(section ".init") extern const char _f_init_rom[];
+__declspec(section ".init") extern char _f_init[];
+__declspec(section ".init") extern char _e_init[];
+__declspec(section ".init") extern const char _f_text_rom[];
+__declspec(section ".init") extern char _f_text[];
+__declspec(section ".init") extern char _e_text[];
+__declspec(section ".init") extern const char _f_rodata_rom[];
+__declspec(section ".init") extern char _f_rodata[];
+__declspec(section ".init") extern char _e_rodata[];
+__declspec(section ".init") extern const char _fextab_rom[];
+__declspec(section ".init") extern char _fextab[];
+__declspec(section ".init") extern char _eextab[];
+__declspec(section ".init") extern const char _f_data_rom[];
+__declspec(section ".init") extern char _f_data[];
+__declspec(section ".init") extern char _e_data[];
+__declspec(section ".init") extern char _f_bss[];
+__declspec(section ".init") extern char _e_bss[];
+__declspec(section ".init") extern const char _f_sdata_rom[];
+__declspec(section ".init") extern char _f_sdata[];
+__declspec(section ".init") extern char _e_sdata[];
+__declspec(section ".init") extern char _f_sbss[];
+__declspec(section ".init") extern char _e_sbss[];
+__declspec(section ".init") extern const char _f_sdata2_rom[];
+__declspec(section ".init") extern char _f_sdata2[];
+__declspec(section ".init") extern char _e_sdata2[];
+__declspec(section ".init") extern char _f_sbss2[];
+__declspec(section ".init") extern char _e_sbss2[];
+__declspec(section ".init") extern const char _f_PPC_EMB_sdata0_rom[];
+__declspec(section ".init") extern char _f_PPC_EMB_sdata0[];
+__declspec(section ".init") extern char _e_PPC_EMB_sdata0[];
+__declspec(section ".init") extern char _f_PPC_EMB_sbss0[];
+__declspec(section ".init") extern char _e_PPC_EMB_sbss0[];
+
+#endif // __PPC_EABI_LINKER

include/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/dispatch.h

@@ -0,0 +1,35 @@
+#ifndef METROTRK_PORTABLE_DISPATCH_H
+#define METROTRK_PORTABLE_DISPATCH_H
+
+#include "dolphin/types.h"
+#include "PowerPC_EABI_Support/MetroTRK/trk.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define TRK_DISPATCH_CMD_CONNECT        1  /* Connect to the console */
+#define TRK_DISPATCH_CMD_DISCONNECT     2  /* Disconnect from the console */
+#define TRK_DISPATCH_CMD_RESET          3  /* Reset the debugger */
+#define TRK_DISPATCH_CMD_GETVERSION     4  /* Get debugger version */
+#define TRK_DISPATCH_CMD_GETSUPPORTMASK 5  /* Get Support Mask */
+#define TRK_DISPATCH_CMD_OVERRIDE       7  /* Override? */
+#define TRK_DISPATCH_CMD_READMEM        16 /* Reading from memory */
+#define TRK_DISPATCH_CMD_WRITEMEM       17 /* Writing to memory */
+#define TRK_DISPATCH_CMD_READREGS       18 /* Read a register value */
+#define TRK_DISPATCH_CMD_WRITEREGS      19 /* Set a register */
+#define TRK_DISPATCH_CMD_SETOPTION      23 /* Set an option? */
+#define TRK_DISPATCH_CMD_CONTINUE       24 /* Continue debugging */
+#define TRK_DISPATCH_CMD_STEP           25 /* Step through an instruction */
+#define TRK_DISPATCH_CMD_STOP           26 /* Stop the debugger */
+
+typedef struct TRKBuffer TRKBuffer;
+
+DSError TRKInitializeDispatcher();
+BOOL TRKDispatchMessage(TRKBuffer* buffer);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* METROTRK_PORTABLE_DISPATCH_H */

include/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/main_TRK.h

@@ -0,0 +1,16 @@
+#ifndef METROTRK_PORTABLE_MAIN_TRK_H
+#define METROTRK_PORTABLE_MAIN_TRK_H
+
+#include "PowerPC_EABI_Support/MetroTRK/trk.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+DSError TRK_main(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* METROTRK_PORTABLE_MAIN_TRK_H */

include/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mainloop.h

@@ -0,0 +1,14 @@
+#ifndef METROTRK_PORTABLE_MAINLOOP_H
+#define METROTRK_PORTABLE_MAINLOOP_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void TRKNubMainLoop(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* METROTRK_PORTABLE_MAINLOOP_H */

include/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mem_TRK.h

@@ -0,0 +1,17 @@
+#ifndef METROTRK_PORTABLE_MEM_TRK_H
+#define METROTRK_PORTABLE_MEM_TRK_H
+
+#include "stddef.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void* TRK_memset(void* dst, int val, size_t n);
+void* TRK_memcpy(void* dst, const void* src, size_t n);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* METROTRK_PORTABLE_MEM_TRK_H */

include/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msg.h

@@ -0,0 +1,24 @@
+#ifndef METROTRK_PORTABLE_MSG_H
+#define METROTRK_PORTABLE_MSG_H
+
+#include "PowerPC_EABI_Support/MetroTRK/trk.h"
+#include "dolphin/types.h"
+
+typedef struct _TRK_Msg {
+	u8 _00[8];
+	u32 m_msgLength;
+	u32 _0C;
+	u32 m_msg;
+} TRK_Msg;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+DSError TRKMessageSend(TRK_Msg* msg);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* METROTRK_PORTABLE_MSG_H */

include/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msgbuf.h

@@ -0,0 +1,50 @@
+#ifndef METROTRK_PORTABLE_MSGBUF_H
+#define METROTRK_PORTABLE_MSGBUF_H
+
+#include "PowerPC_EABI_Support/MetroTRK/trk.h"
+#include "stddef.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+DSError TRKInitializeMessageBuffers(void);
+
+DSError TRKSetBufferPosition(TRKBuffer* msg, u32 pos);
+void* TRKGetBuffer(int);
+void TRKResetBuffer(TRKBuffer* msg, BOOL keepData);
+void* TRKGetBuffer(int idx);
+void TRKReleaseBuffer(int idx);
+DSError TRKGetFreeBuffer(int* msgID, TRKBuffer** outMsg);
+
+DSError TRKAppendBuffer(TRKBuffer* msg, const void* data, size_t length);
+DSError TRKAppendBuffer1_ui8(TRKBuffer* buffer, const u8 data);
+inline DSError TRKAppendBuffer1_ui8(TRKBuffer* buffer, const u8 data)
+{
+	if (buffer->position >= TRKMSGBUF_SIZE) {
+		return DS_MessageBufferOverflow;
+	}
+
+	buffer->data[buffer->position++] = data;
+	buffer->length++;
+	return DS_NoError;
+}
+DSError TRKAppendBuffer1_ui16(TRKBuffer* buffer, const u16 data);
+DSError TRKAppendBuffer1_ui32(TRKBuffer* buffer, const u32 data);
+DSError TRKAppendBuffer1_ui64(TRKBuffer* buffer, const u64 data);
+DSError TRKAppendBuffer_ui8(TRKBuffer* buffer, const u8* data, int count);
+DSError TRKAppendBuffer_ui32(TRKBuffer* buffer, const u32* data, int count);
+
+DSError TRKReadBuffer1_ui8(TRKBuffer* buffer, u8* data);
+DSError TRKReadBuffer1_ui16(TRKBuffer* buffer, u16* data);
+DSError TRKReadBuffer1_ui32(TRKBuffer* buffer, u32* data);
+DSError TRKReadBuffer1_ui64(TRKBuffer* buffer, u64* data);
+DSError TRKReadBuffer_ui8(TRKBuffer* buffer, u8* data, int count);
+DSError TRKReadBuffer_ui32(TRKBuffer* buffer, u32* data, int count);
+DSError TRKReadBuffer(TRKBuffer* msg, void* data, size_t length);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* METROTRK_PORTABLE_MSGBUF_H */

include/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr.h

@@ -0,0 +1,31 @@
+#ifndef METROTRK_PORTABLE_MSGHNDLR_H
+#define METROTRK_PORTABLE_MSGHNDLR_H
+
+#include "PowerPC_EABI_Support/MetroTRK/trk.h"
+
+void SetTRKConnected(BOOL);
+BOOL GetTRKConnected(void);
+DSError TRKDoUnsupported(TRKBuffer*);
+DSError TRKDoSetOption(TRKBuffer*);
+DSError TRKDoStop(TRKBuffer*);
+DSError TRKDoStep(TRKBuffer*);
+DSError TRKDoContinue(TRKBuffer*);
+DSError TRKDoWriteRegisters(TRKBuffer*);
+DSError TRKDoReadRegisters(TRKBuffer*);
+DSError TRKDoFlushCache(TRKBuffer*);
+DSError TRKDoWriteMemory(TRKBuffer*);
+DSError TRKDoReadMemory(TRKBuffer*);
+DSError TRKDoSupportMask(TRKBuffer*);
+DSError TRKDoVersions(TRKBuffer*);
+DSError TRKDoSupportMask(TRKBuffer*);
+DSError TRKDoCPUType(TRKBuffer*);
+DSError TRKDoOverride(TRKBuffer*);
+DSError TRKDoReset(TRKBuffer*);
+DSError TRKDoDisconnect(TRKBuffer*);
+DSError TRKDoConnect(TRKBuffer*);
+DSError TRKStandardACK(TRKBuffer* buffer, MessageCommandID commandID,
+                       DSReplyError replyError);
+
+void OutputData(void* data, int length);
+
+#endif /* METROTRK_PORTABLE_MSGHNDLR_H */

include/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mutex_TRK.h

@@ -0,0 +1,10 @@
+#ifndef METROTRK_PORTABLE_MUTEX_TRK_H
+#define METROTRK_PORTABLE_MUTEX_TRK_H
+
+#include "PowerPC_EABI_Support/MetroTRK/trk.h"
+
+DSError TRKInitializeMutex(void*);
+DSError TRKAcquireMutex(void*);
+DSError TRKReleaseMutex(void*);
+
+#endif /* METROTRK_PORTABLE_MUTEX_TRK_H */

include/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/notify.h

@@ -0,0 +1,16 @@
+#ifndef METROTRK_PORTABLE_NOTIFY_H
+#define METROTRK_PORTABLE_NOTIFY_H
+
+#include "PowerPC_EABI_Support/MetroTRK/trk.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+DSError TRKDoNotifyStopped(MessageCommandID cmd);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* METROTRK_PORTABLE_NOTIFY_H */

include/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/nubevent.h

@@ -0,0 +1,37 @@
+#ifndef METROTRK_PORTABLE_NUBEVENT_H
+#define METROTRK_PORTABLE_NUBEVENT_H
+
+#include "PowerPC_EABI_Support/MetroTRK/trk.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef u32 NubEventID;
+
+typedef struct TRKEvent {
+	NubEventType eventType;
+	NubEventID eventID;
+	MessageBufferID msgBufID;
+} TRKEvent;
+
+typedef struct TRKEventQueue {
+	int _00;
+	int count;
+	int next;
+	TRKEvent events[2];
+	NubEventID eventID;
+} TRKEventQueue;
+extern TRKEventQueue gTRKEventQueue;
+
+BOOL TRKGetNextEvent(TRKEvent* event);
+void TRKDestructEvent(TRKEvent*);
+void TRKConstructEvent(TRKEvent*, NubEventType);
+DSError TRKPostEvent(TRKEvent*);
+DSError TRKInitializeEventQueue();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* METROTRK_PORTABLE_NUBEVENT_H */

include/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/nubinit.h

@@ -0,0 +1,21 @@
+#ifndef METROTRK_PORTABLE_NUBINIT_H
+#define METROTRK_PORTABLE_NUBINIT_H
+
+#include "PowerPC_EABI_Support/MetroTRK/trk.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void TRKNubWelcome(void);
+void TRKNubMainLoop(void);
+DSError TRKTerminateNub(void);
+DSError TRKInitializeNub(void);
+
+extern BOOL gTRKBigEndian;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* METROTRK_PORTABLE_NUBINIT_H */

include/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/serpoll.h

@@ -0,0 +1,23 @@
+#ifndef METROTRK_PORTABLE_SERPOLL_H
+#define METROTRK_PORTABLE_SERPOLL_H
+
+#include "PowerPC_EABI_Support/MetroTRK/trk.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+DSError TRKInitializeSerialHandler(void);
+DSError TRKTerminateSerialHandler(void);
+
+void TRKGetInput(void);
+MessageBufferID TRKTestForPacket();
+void TRKProcessInput(int bufferIdx);
+
+extern void* gTRKInputPendingPtr;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* METROTRK_PORTABLE_SERPOLL_H */

include/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/support.h

@@ -0,0 +1,29 @@
+#ifndef METROTRK_PORTABLE_SUPPORT_H
+#define METROTRK_PORTABLE_SUPPORT_H
+
+#include "PowerPC_EABI_Support/MetroTRK/trk.h"
+#include "stddef.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+DSError TRKSuppAccessFile(u32 file_handle, u8* data, size_t* count,
+                          DSIOResult* io_result, BOOL need_reply, BOOL read);
+
+DSError TRKRequestSend(TRKBuffer* msgBuf, int* bufferId, u32 p1, u32 p2,
+                       int p3);
+
+DSError HandleOpenFileSupportRequest(const char* path, u8 replyError,
+                                     u32* param_3, DSIOResult* ioResult);
+
+DSError HandleCloseFileSupportRequest(int replyError, DSIOResult* ioResult);
+
+DSError HandlePositionFileSupportRequest(DSReplyError replyErr, u32* param_2,
+                                         u8 param_3, DSIOResult* ioResult);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* METROTRK_PORTABLE_SUPPORT_H */

include/TRK_MINNOW_DOLPHIN/Os/dolphin/dolphin_trk.h

@@ -0,0 +1,24 @@
+#ifndef OS_DOLPHIN_DOLPHIN_TRK_H
+#define OS_DOLPHIN_DOLPHIN_TRK_H
+
+#include "dolphin/types.h"
+#include "PowerPC_EABI_Support/MetroTRK/trk.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+DSError TRKInitializeTarget();
+
+void EnableMetroTRKInterrupts();
+u32 TRKTargetTranslate(u32 param_0);
+void TRK__read_aram(register int c, register u32 p2, void* p3);
+void TRK__write_aram(register int c, register u32 p2, void* p3);
+
+void __TRK_copy_vectors(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OS_DOLPHIN_DOLPHIN_TRK_H */

include/TRK_MINNOW_DOLPHIN/Os/dolphin/dolphin_trk_glue.h

@@ -0,0 +1,45 @@
+#ifndef OS_DOLPHIN_DOLPHIN_TRK_GLUE_H
+#define OS_DOLPHIN_DOLPHIN_TRK_GLUE_H
+
+#include "dolphin/os.h"
+#include "PowerPC_EABI_Support/MetroTRK/trk.h"
+#include "stddef.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*DBCommFunc)(void);
+typedef u32 (*DBPollFunc)(void);
+typedef void (*DBCommInitFunc)(volatile u8**, __OSInterruptHandler);
+typedef int (*DBCommReadFunc)(void*, size_t);
+typedef int (*DBCommWriteFunc)(const void*, size_t);
+
+typedef struct DBCommTable {
+	DBCommInitFunc initialize_func;
+	DBCommFunc init_interrupts_func;
+	DBPollFunc peek_func;
+	DBCommReadFunc read_func;
+	DBCommWriteFunc write_func;
+	DBCommFunc open_func;
+	DBCommFunc close_func;
+} DBCommTable;
+
+DSError TRKInitializeIntDrivenUART(u32 param_0, u32 param_1, u32 param_2,
+                                   volatile u8** param_3);
+
+void UnreserveEXI2Port(void);
+void ReserveEXI2Port(void);
+int TRKPollUART(void);
+UARTError TRKReadUARTN(void* bytes, u32 length);
+UARTError TRKWriteUARTN(const void* bytes, u32 length);
+void TRKLoadContext(OSContext* ctx, u32 r4);
+int InitMetroTRKCommTable(int hwId);
+void EnableEXI2Interrupts(void);
+void TRK_board_display(char* str);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OS_DOLPHIN_DOLPHIN_TRK_GLUE_H */

include/TRK_MINNOW_DOLPHIN/Os/dolphin/targcont.h

@@ -0,0 +1,16 @@
+#ifndef OS_DOLPHIN_TARGCONT_H
+#define OS_DOLPHIN_TARGCONT_H
+
+#include "PowerPC_EABI_Support/MetroTRK/trk.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+DSError TRKTargetContinue(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OS_DOLPHIN_TARGCONT_H */

include/TRK_MINNOW_DOLPHIN/Os/dolphin/usr_put.h

@@ -0,0 +1,14 @@
+#ifndef OS_DOLPHIN_USR_PUT_H
+#define OS_DOLPHIN_USR_PUT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void usr_put_initialize(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* OS_DOLPHIN_USR_PUT_H */

include/TRK_MINNOW_DOLPHIN/ppc/Generic/flush_cache.h

@@ -0,0 +1,16 @@
+#ifndef PPC_GENERIC_FLUSH_CACHE_H
+#define PPC_GENERIC_FLUSH_CACHE_H
+
+#include <dolphin/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void TRK_flush_cache(void* param_1, int param_2);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* PPC_GENERIC_FLUSH_CACHE_H */

include/TRK_MINNOW_DOLPHIN/ppc/Generic/mpc_7xx_603e.h

@@ -0,0 +1,16 @@
+#ifndef PPC_GENERIC_MPC_7XX_603E_H
+#define PPC_GENERIC_MPC_7XX_603E_H
+
+#include <dolphin/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+u32 TRKTargetCPUMinorType(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* PPC_GENERIC_MPC_7XX_603E_H */

include/TRK_MINNOW_DOLPHIN/ppc/Generic/targimpl.h

@@ -0,0 +1,190 @@
+#ifndef PPC_GENERIC_TARGIMPL_H
+#define PPC_GENERIC_TARGIMPL_H
+
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/nubevent.h"
+#include "stddef.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void TRKTargetSetInputPendingPtr(void* ptr);
+
+void TRKSwapAndGo();
+void TRKTargetSetStopped(unsigned int);
+DSError TRKTargetInterrupt(TRKEvent*);
+DSError TRKTargetSupportRequest();
+void TRKDestructEvent(TRKEvent*);
+DSError TRKTargetFlushCache(u8, void* start, void* end);
+BOOL TRKTargetStopped(void);
+DSError TRKTargetAddStopInfo(TRKBuffer* b);
+DSError TRKTargetAddExceptionInfo(TRKBuffer* b);
+DSError TRKTargetAccessARAM(u32 p1, u32 p2, u32* p3, BOOL read);
+DSError TRKTargetAccessMemory(void* data, u32 start, size_t* length,
+                              MemoryAccessOptions accessOptions, BOOL read);
+DSError TRKTargetAccessDefault(u32 firstRegister, u32 lastRegister,
+                               TRKBuffer* b, size_t* registersLengthPtr,
+                               BOOL read);
+DSError TRKTargetAccessFP(u32 firstRegister, u32 lastRegister, TRKBuffer* b,
+                          size_t* registersLengthPtr, BOOL read);
+DSError TRKTargetAccessExtended1(u32 firstRegister, u32 lastRegister,
+                                 TRKBuffer* b, size_t* registersLengthPtr,
+                                 BOOL read);
+DSError TRKTargetAccessExtended2(u32 firstRegister, u32 lastRegister,
+                                 TRKBuffer* b, size_t* registerStorageSize,
+                                 BOOL read);
+u32 TRKTargetGetPC();
+DSError TRKTargetSingleStep(u32 count, BOOL stepOver);
+DSError TRKTargetStepOutOfRange(u32 rangeStart, u32 rangeEnd, BOOL stepOver);
+u32 TRKTargetStop();
+void TRKInterruptHandler();
+void TRKPostInterruptEvent(void);
+
+typedef struct DSVersions {
+	u8 kernelMajor;
+	u8 kernelMinor;
+	u8 protocolMajor;
+	u8 protocolMinor;
+} DSVersions;
+
+DSError TRKTargetVersions(DSVersions* versions);
+DSError TRKTargetSupportMask(u8 mask[32]);
+
+typedef struct DSCPUType {
+	u8 cpuMajor;
+	u8 cpuMinor;
+	u8 bigEndian;
+	u8 defaultTypeSize;
+	u8 fpTypeSize;
+	u8 extended1TypeSize;
+	u8 extended2TypeSize;
+} DSCPUType;
+DSError TRKTargetCPUType(DSCPUType* cpuType);
+
+typedef struct Default_PPC {
+	u32 GPR[32];
+	u32 PC;
+	u32 LR;
+	u32 CR;
+	u32 CTR;
+	u32 XER;
+} Default_PPC;
+
+typedef struct Float_PPC {
+	u64 FPR[32];
+	u64 FPSCR;
+	u64 FPECR;
+} Float_PPC;
+
+typedef struct Extended1_PPC_6xx_7xx {
+	u32 SR[16];
+	u32 TBL;
+	u32 TBU;
+	u32 HID0;
+	u32 HID1;
+	u32 MSR;
+	u32 PVR;
+	u32 IBAT0U;
+	u32 IBAT0L;
+	u32 IBAT1U;
+	u32 IBAT1L;
+	u32 IBAT2U;
+	u32 IBAT2L;
+	u32 IBAT3U;
+	u32 IBAT3L;
+	u32 DBAT0U;
+	u32 DBAT0L;
+	u32 DBAT1U;
+	u32 DBAT1L;
+	u32 DBAT2U;
+	u32 DBAT2L;
+	u32 DBAT3U;
+	u32 DBAT3L;
+	u32 DMISS;
+	u32 DCMP;
+	u32 HASH1;
+	u32 HASH2;
+	u32 IMISS;
+	u32 ICMP;
+	u32 RPA;
+	u32 SDR1;
+	u32 DAR;
+	u32 DSISR;
+	u32 SPRG0;
+	u32 SPRG1;
+	u32 SPRG2;
+	u32 SPRG3;
+	u32 DEC;
+	u32 IABR;
+	u32 EAR;
+	u32 DABR;
+	u32 PMC1;
+	u32 PMC2;
+	u32 PMC3;
+	u32 PMC4;
+	u32 SIA;
+	u32 MMCR0;
+	u32 MMCR1;
+	u32 THRM1;
+	u32 THRM2;
+	u32 THRM3;
+	u32 ICTC;
+	u32 L2CR;
+	u32 UMMCR2;
+	u32 UBAMR;
+	u32 UMMCR0;
+	u32 UPMC1;
+	u32 UPMC2;
+	u32 USIA;
+	u32 UMMCR1;
+	u32 UPMC3;
+	u32 UPMC4;
+	u32 USDA;
+	u32 MMCR2;
+	u32 BAMR;
+	u32 SDA;
+	u32 MSSCR0;
+	u32 MSSCR1;
+	u32 PIR;
+	u32 exceptionID;
+	u32 GQR[8];
+	u32 HID_G;
+	u32 WPAR;
+	u32 DMA_U;
+	u32 DMA_L;
+} Extended1_PPC_6xx_7xx;
+
+typedef struct Extended2_PPC_6xx_7xx {
+	u32 PSR[32][2];
+} Extended2_PPC_6xx_7xx;
+
+typedef struct ProcessorState_PPC_6xx_7xx {
+	Default_PPC Default;
+	Float_PPC Float;
+	Extended1_PPC_6xx_7xx Extended1;
+	Extended2_PPC_6xx_7xx Extended2;
+	u32 transport_handler_saved_ra;
+} ProcessorState_PPC_6xx_7xx;
+
+typedef ProcessorState_PPC_6xx_7xx ProcessorState_PPC;
+extern ProcessorState_PPC gTRKCPUState;
+
+typedef struct TRKState {
+	u32 gpr[32];           // _00
+	u32 lr;                // _80
+	u32 ctr;               // _84
+	u32 xer;               // _88
+	u32 msr;               // _8C
+	u32 dar;               // _90
+	u32 dsisr;             // _94
+	BOOL isStopped;        // _98
+	BOOL inputActivated;   // _9C
+	void* inputPendingPtr; // _A0
+} TRKState;
+extern TRKState gTRKState;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* PPC_GENERIC_TARGIMPL_H */

include/amcstubs/AmcExi2Stubs.h

@@ -0,0 +1,27 @@
+#ifndef AMCEXI2STUBS_H
+#define AMCEXI2STUBS_H
+
+#include "dolphin/os.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef __OSInterruptHandler AmcEXICallback;
+
+typedef enum { AMC_EXI_NO_ERROR = 0, AMC_EXI_UNSELECTED } AmcExiError;
+
+void EXI2_Init(volatile u8**, AmcEXICallback);
+void EXI2_EnableInterrupts(void);
+u32 EXI2_Poll(void);
+int EXI2_ReadN(void*, u32);
+int EXI2_WriteN(const void*, u32);
+void EXI2_Reserve(void);
+void EXI2_Unreserve(void);
+BOOL AMC_IsStub(void);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif

src/TRK_MINNOW_DOLPHIN/dispatch.c

@@ -0,0 +1,43 @@
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/dispatch.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msgbuf.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr.h"
+
+u32 gTRKDispatchTableSize;
+
+struct DispatchEntry {
+	int (*fn)(TRKBuffer*);
+};
+
+struct DispatchEntry gTRKDispatchTable[33] = {
+	{ &TRKDoUnsupported },   { &TRKDoConnect },        { &TRKDoDisconnect },
+	{ &TRKDoReset },         { &TRKDoVersions },       { &TRKDoSupportMask },
+	{ &TRKDoCPUType },       { &TRKDoUnsupported },    { &TRKDoUnsupported },
+	{ &TRKDoUnsupported },   { &TRKDoUnsupported },    { &TRKDoUnsupported },
+	{ &TRKDoUnsupported },   { &TRKDoUnsupported },    { &TRKDoUnsupported },
+	{ &TRKDoUnsupported },   { &TRKDoReadMemory },     { &TRKDoWriteMemory },
+	{ &TRKDoReadRegisters }, { &TRKDoWriteRegisters }, { &TRKDoUnsupported },
+	{ &TRKDoUnsupported },   { &TRKDoFlushCache },     { &TRKDoUnsupported },
+	{ &TRKDoContinue },      { &TRKDoStep },           { &TRKDoStop },
+	{ &TRKDoUnsupported },   { &TRKDoUnsupported },    { &TRKDoUnsupported },
+	{ &TRKDoUnsupported },   { &TRKDoUnsupported },
+};
+
+DSError TRKInitializeDispatcher()
+{
+	gTRKDispatchTableSize = 32;
+	return DS_NoError;
+}
+
+DSError TRKDispatchMessage(TRKBuffer* buffer)
+{
+	DSError error;
+	u8 command;
+
+	error = DS_DispatchError;
+	TRKSetBufferPosition(buffer, 0);
+	TRKReadBuffer1_ui8(buffer, &command);
+	if (command < gTRKDispatchTableSize) {
+		error = gTRKDispatchTable[command].fn(buffer);
+	}
+	return error;
+}

src/TRK_MINNOW_DOLPHIN/dolphin_trk.c

@@ -0,0 +1,137 @@
+#include "TRK_MINNOW_DOLPHIN/Os/dolphin/dolphin_trk.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/main_TRK.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mem_TRK.h"
+#include "TRK_MINNOW_DOLPHIN/Os/dolphin/dolphin_trk_glue.h"
+#include "TRK_MINNOW_DOLPHIN/ppc/Generic/targimpl.h"
+#include "TRK_MINNOW_DOLPHIN/ppc/Generic/flush_cache.h"
+#include "dolphin/ar.h"
+#include "stddef.h"
+
+#define EXCEPTIONMASK_ADDR 0x80000044
+
+static u32 lc_base;
+
+static u32 TRK_ISR_OFFSETS[15] = { PPC_SystemReset,
+	                               PPC_MachineCheck,
+	                               PPC_DataStorage,
+	                               PPC_InstructionStorage,
+	                               PPC_ExternalInterrupt,
+	                               PPC_Alignment,
+	                               PPC_Program,
+	                               PPC_FloatingPointUnavaiable,
+	                               PPC_Decrementer,
+	                               PPC_SystemCall,
+	                               PPC_Trace,
+	                               PPC_PerformanceMonitor,
+	                               PPC_InstructionAddressBreakpoint,
+	                               PPC_SystemManagementInterrupt,
+	                               PPC_ThermalManagementInterrupt };
+
+__declspec(section ".init") void __TRK_reset(void) { __TRK_copy_vectors(); }
+
+asm void InitMetroTRK()
+{
+#ifdef __MWERKS__ // clang-format off
+	nofralloc
+
+	addi r1, r1, -4
+	stw r3, 0(r1)
+	lis r3, gTRKCPUState@h
+	ori r3, r3, gTRKCPUState@l
+	stmw r0, ProcessorState_PPC.Default.GPR(r3) //Save the gprs
+	lwz r4, 0(r1)
+	addi r1, r1, 4
+	stw r1, ProcessorState_PPC.Default.GPR[1](r3)
+	stw r4, ProcessorState_PPC.Default.GPR[3](r3)
+	mflr r4
+	stw r4, ProcessorState_PPC.Default.LR(r3)
+	stw r4, ProcessorState_PPC.Default.PC(r3)
+	mfcr r4
+	stw r4, ProcessorState_PPC.Default.CR(r3)
+	//???
+	mfmsr r4
+	ori r3, r4, (1 << (31 - 16))
+	xori r3, r3, (1 << (31 - 16))
+	mtmsr r3
+	mtsrr1 r4 //Copy msr to srr1
+	//Save misc registers to gTRKCPUState
+	bl TRKSaveExtended1Block
+	lis r3, gTRKCPUState@h
+	ori r3, r3, gTRKCPUState@l
+	lmw r0, ProcessorState_PPC.Default.GPR(r3) //Restore the gprs
+	//Reset IABR and DABR
+	li r0, 0
+	mtspr  0x3f2, r0
+	mtspr  0x3f5, r0
+	//Restore stack pointer
+	lis r1, 0x80426008@h
+	ori r1, r1, 0x80426008@l
+	mr r3, r5
+	bl InitMetroTRKCommTable //Initialize comm table
+	/*
+	If InitMetroTRKCommTable returned 1 (failure), an invalid hardware
+	id or the id for GDEV was somehow passed. Since only BBA or NDEV
+	are supported, we return early. Otherwise, we proceed with
+	starting up TRK.
+	*/
+	cmpwi r3, 1
+	bne initCommTableSuccess
+	/*
+	BUG: The code probably orginally reloaded gTRKCPUState here, but
+	as is it will read the returned value of InitMetroTRKCommTable
+	as a TRKCPUState struct pointer, causing the CPU to return to
+	a garbage code address.
+	*/
+	lwz r4, ProcessorState_PPC.Default.LR(r3)
+	mtlr r4
+	lmw r0, ProcessorState_PPC.Default.GPR(r3) //Restore the gprs
+	blr
+initCommTableSuccess:
+	b TRK_main //Jump to TRK_main
+#endif // clang-format on
+}
+
+void EnableMetroTRKInterrupts(void) { EnableEXI2Interrupts(); }
+
+u32 TRKTargetTranslate(u32 param_0)
+{
+	if (param_0 >= lc_base) {
+		if ((param_0 < lc_base + 0x4000)
+		    && ((gTRKCPUState.Extended1.DBAT3U & 3) != 0)) {
+			return param_0;
+		}
+	}
+
+	return param_0 & 0x3FFFFFFF | 0x80000000;
+}
+
+extern u8 gTRKInterruptVectorTable[];
+
+void TRK_copy_vector(u32 offset)
+{
+	void* destPtr = (void*)TRKTargetTranslate(offset);
+	TRK_memcpy(destPtr, gTRKInterruptVectorTable + offset, 0x100);
+	TRK_flush_cache(destPtr, 0x100);
+}
+
+void __TRK_copy_vectors(void)
+{
+	int i;
+	u32 mask;
+
+	mask = *(u32*)TRKTargetTranslate(0x44);
+
+	for (i = 0; i <= 14; ++i) {
+		if (mask & (1 << i)) {
+			TRK_copy_vector(TRK_ISR_OFFSETS[i]);
+		}
+	}
+}
+
+DSError TRKInitializeTarget()
+{
+	gTRKState.isStopped = TRUE;
+	gTRKState.msr       = __TRK_get_MSR();
+	lc_base             = 0xE0000000;
+	return DS_NoError;
+}

src/TRK_MINNOW_DOLPHIN/dolphin_trk_glue.c

@@ -0,0 +1,116 @@
+#include "TRK_MINNOW_DOLPHIN/Os/dolphin/dolphin_trk_glue.h"
+#include "TRK_MINNOW_DOLPHIN/ppc/Generic/targimpl.h"
+#include "OdemuExi2/odemuexi/DebuggerDriver.h"
+#include "amcstubs/AmcExi2Stubs.h"
+#include "PowerPC_EABI_Support/MetroTRK/trk.h"
+
+DBCommTable gDBCommTable = {};
+
+asm void TRKLoadContext(OSContext* ctx, u32)
+{
+#ifdef __MWERKS__ // clang-format off
+	nofralloc
+	lwz r0, OSContext.gpr[0](r3)
+	lwz r1, OSContext.gpr[1](r3)
+	lwz r2, OSContext.gpr[2](r3)
+	lhz r5, OSContext.state(r3)
+	rlwinm. r6, r5, 0, 0x1e, 0x1e
+	beq lbl_80371C1C
+	rlwinm r5, r5, 0, 0x1f, 0x1d
+	sth r5, OSContext.state(r3)
+	lmw r5, OSContext.gpr[5](r3)
+	b lbl_80371C20
+lbl_80371C1C:
+	lmw r13, OSContext.gpr[13](r3)
+lbl_80371C20:
+	mr r31, r3
+	mr r3, r4
+	lwz r4, OSContext.cr(r31)
+	mtcrf 0xff, r4
+	lwz r4, OSContext.lr(r31)
+	mtlr r4
+	lwz r4, OSContext.ctr(r31)
+	mtctr r4
+	lwz r4, OSContext.xer(r31)
+	mtxer r4
+	mfmsr r4
+	rlwinm r4, r4, 0, 0x11, 0xf //Turn off external exceptions
+	rlwinm r4, r4, 0, 0x1f, 0x1d //Turn off recoverable exception flag
+	mtmsr r4
+	mtsprg 1, r2
+	lwz r4, OSContext.gpr[3](r31)
+	mtsprg 2, r4
+	lwz r4, OSContext.gpr[4](r31)
+	mtsprg 3, r4
+	lwz r2, OSContext.srr0(r31)
+	lwz r4, OSContext.srr1(r31)
+	lwz r31, OSContext.gpr[31](r31)
+	b TRKInterruptHandler
+#endif // clang-format on
+}
+
+void TRKEXICallBack(__OSInterrupt param_0, OSContext* ctx)
+{
+	OSEnableScheduler();
+	TRKLoadContext(ctx, 0x500);
+}
+
+int InitMetroTRKCommTable(int hwId)
+{
+	int result;
+
+	if (hwId == HARDWARE_GDEV) {
+		result = Hu_IsStub();
+
+		gDBCommTable.initialize_func      = DBInitComm;
+		gDBCommTable.init_interrupts_func = DBInitInterrupts;
+		gDBCommTable.peek_func            = DBQueryData;
+		gDBCommTable.read_func            = DBRead;
+		gDBCommTable.write_func           = DBWrite;
+		gDBCommTable.open_func            = DBOpen;
+		gDBCommTable.close_func           = DBClose;
+	} else {
+		result = AMC_IsStub();
+
+		gDBCommTable.initialize_func      = EXI2_Init;
+		gDBCommTable.init_interrupts_func = EXI2_EnableInterrupts;
+		gDBCommTable.peek_func            = EXI2_Poll;
+		gDBCommTable.read_func            = EXI2_ReadN;
+		gDBCommTable.write_func           = EXI2_WriteN;
+		gDBCommTable.open_func            = EXI2_Reserve;
+		gDBCommTable.close_func           = EXI2_Unreserve;
+	}
+
+	return result;
+}
+
+void TRKUARTInterruptHandler() { }
+
+DSError TRKInitializeIntDrivenUART(u32 param_0, u32 param_1, u32 param_2,
+                                   volatile u8** param_3)
+{
+	gDBCommTable.initialize_func(param_3, TRKEXICallBack);
+	return DS_NoError;
+}
+
+void EnableEXI2Interrupts(void) { gDBCommTable.init_interrupts_func(); }
+
+int TRKPollUART(void) { return gDBCommTable.peek_func(); }
+
+UARTError TRKReadUARTN(void* bytes, u32 length)
+{
+	int readErr = gDBCommTable.read_func(bytes, length);
+	return readErr == 0 ? 0 : -1;
+}
+
+UARTError TRKWriteUARTN(const void* bytes, u32 length)
+{
+	int writeErr = gDBCommTable.write_func(bytes, length);
+	return writeErr == 0 ? 0 : -1;
+}
+
+void ReserveEXI2Port(void) { gDBCommTable.open_func(); }
+
+void UnreserveEXI2Port(void) { gDBCommTable.close_func(); }
+
+void TRK_board_display(char* str) { OSReport(str); }

src/TRK_MINNOW_DOLPHIN/flush_cache.c

@@ -0,0 +1,26 @@
+#include "TRK_MINNOW_DOLPHIN/ppc/Generic/flush_cache.h"
+
+asm void TRK_flush_cache(register void* param_1, register int param_2)
+{
+#ifdef __MWERKS__ // clang-format off
+	nofralloc
+
+	lis r5, 0xFFFF
+	ori r5, r5, 0xFFF1
+	and r5, r5, param_1
+	subf r3, r5, param_1
+	add r4, param_2, r3
+
+loop:
+	dcbst 0, r5
+	dcbf 0, r5
+	sync
+	icbi 0, r5
+	addic r5, r5, 8
+	addic. r4, r4, -8
+	bge loop
+
+	isync
+	blr
+#endif // clang-format on
+}

src/TRK_MINNOW_DOLPHIN/main_TRK.c

@@ -0,0 +1,17 @@
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/main_TRK.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/nubinit.h"
+
+static DSError TRK_mainError;
+
+DSError TRK_main(void)
+{
+	TRK_mainError = TRKInitializeNub();
+
+	if (TRK_mainError == DS_NoError) {
+		TRKNubWelcome();
+		TRKNubMainLoop();
+	}
+
+	TRK_mainError = TRKTerminateNub();
+	return TRK_mainError;
+}

src/TRK_MINNOW_DOLPHIN/mainloop.c

@@ -0,0 +1,70 @@
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/serpoll.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msgbuf.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/dispatch.h"
+#include "TRK_MINNOW_DOLPHIN/Os/dolphin/targcont.h"
+#include "TRK_MINNOW_DOLPHIN/ppc/Generic/targimpl.h"
+
+void TRKHandleRequestEvent(TRKEvent* event)
+{
+	TRKBuffer* buffer = TRKGetBuffer(event->msgBufID);
+	TRKDispatchMessage(buffer);
+}
+
+void TRKHandleSupportEvent(TRKEvent* event) { TRKTargetSupportRequest(); }
+
+void TRKIdle()
+{
+	if (TRKTargetStopped() == FALSE) {
+		TRKTargetContinue();
+	}
+}
+
+void TRKNubMainLoop(void)
+{
+	void* msg;
+	TRKEvent event;
+	BOOL isShutdownRequested;
+	BOOL isNewInput;
+
+	isShutdownRequested = FALSE;
+	isNewInput          = FALSE;
+	while (isShutdownRequested == FALSE) {
+		if (TRKGetNextEvent(&event) != FALSE) {
+			isNewInput = FALSE;
+
+			switch (event.eventType) {
+			case NUBEVENT_Null:
+				break;
+
+			case NUBEVENT_Request:
+				TRKHandleRequestEvent(&event);
+				break;
+
+			case NUBEVENT_Shutdown:
+				isShutdownRequested = TRUE;
+				break;
+
+			case NUBEVENT_Breakpoint:
+			case NUBEVENT_Exception:
+				TRKTargetInterrupt(&event);
+				break;
+
+			case NUBEVENT_Support:
+				TRKHandleSupportEvent(&event);
+				break;
+			}
+
+			TRKDestructEvent(&event);
+			continue;
+		}
+
+		if ((isNewInput == FALSE) || (*(u8*)gTRKInputPendingPtr != '\0')) {
+			isNewInput = TRUE;
+			TRKGetInput();
+			continue;
+		}
+
+		TRKIdle();
+		isNewInput = FALSE;
+	}
+}

src/TRK_MINNOW_DOLPHIN/mem_TRK.c

@@ -0,0 +1,83 @@
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mem_TRK.h"
+#include "dolphin/types.h"
+
+void TRK_fill_mem(void *dest, int value, unsigned long length)
+{
+#define cDest ((unsigned char *)dest)
+#define lDest ((unsigned long *)dest)
+    unsigned long val = (unsigned char)value;
+    unsigned long i;
+    lDest = (unsigned long *)dest;
+    cDest = (unsigned char *)dest;
+
+    cDest--;
+
+    if (length >= 32) {
+        i = ~(unsigned long)dest & 3;
+
+        if (i) {
+            length -= i;
+            do {
+                *++cDest = val;
+            } while (--i);
+        }
+
+        if (val) {
+            val |= val << 24 | val << 16 | val << 8;
+        }
+
+        lDest = (unsigned long *)(cDest + 1) - 1;
+
+        i = length >> 5;
+        if (i) {
+            do {
+                *++lDest = val;
+                *++lDest = val;
+                *++lDest = val;
+                *++lDest = val;
+                *++lDest = val;
+                *++lDest = val;
+                *++lDest = val;
+                *++lDest = val;
+            } while (--i);
+        }
+
+        i = (length & 31) >> 2;
+
+        if (i) {
+            do {
+                *++lDest = val;
+            } while (--i);
+        }
+
+        cDest = (unsigned char *)(lDest + 1) - 1;
+
+        length &= 3;
+    }
+
+    if (length) {
+        do {
+            *++cDest = val;
+        } while (--length);
+    }
+
+#undef cDest
+#undef lDest
+}
+
+__declspec(section ".init") void *TRK_memcpy(void *dst, const void *src, size_t n)
+{
+    const char *p;
+    char *q;
+
+    for (p = (const char *)src - 1, q = (char *)dst - 1, n++; --n;)
+        *++q = *++p;
+
+    return dst;
+}
+
+__declspec(section ".init") void *TRK_memset(void *dst, int val, size_t n)
+{
+    TRK_fill_mem(dst, val, n);
+    return dst;
+}

src/TRK_MINNOW_DOLPHIN/mpc_7xx_603e.c

@@ -0,0 +1,248 @@
+#include "TRK_MINNOW_DOLPHIN/ppc/Generic/mpc_7xx_603e.h"
+#include "TRK_MINNOW_DOLPHIN/ppc/Generic/targimpl.h"
+
+extern u8 gTRKRestoreFlags[9 + 3 /* padding */];
+
+asm void TRKSaveExtended1Block()
+{
+#ifdef __MWERKS__ // clang-format off
+	nofralloc
+	lis r2, gTRKCPUState@h /* 0x8044F338@h */
+	ori r2, r2, gTRKCPUState@l /* 0x8044F338@l */
+	mfsr r16, 0
+	mfsr r17, 1
+	mfsr r18, 2
+	mfsr r19, 3
+	mfsr r20, 4
+	mfsr r21, 5
+	mfsr r22, 6
+	mfsr r23, 7
+	mfsr r24, 8
+	mfsr r25, 9
+	mfsr r26, 0xa
+	mfsr r27, 0xb
+	mfsr r28, 0xc
+	mfsr r29, 0xd
+	mfsr r30, 0xe
+	mfsr r31, 0xf
+	stmw r16, 0x1a8(r2)
+	mftb r10, 0x10c
+	mftbu r11
+	mfspr r12, 0x3f0
+	mfspr r13, 0x3f1
+	mfspr r14, 0x1b
+	mfpvr r15
+	mfibatu r16, 0
+	mfibatl r17, 0
+	mfibatu r18, 1
+	mfibatl r19, 1
+	mfibatu r20, 2
+	mfibatl r21, 2
+	mfibatu r22, 3
+	mfibatl r23, 3
+	mfdbatu r24, 0
+	mfdbatl r25, 0
+	mfdbatu r26, 1
+	mfdbatl r27, 1
+	mfdbatu r28, 2
+	mfdbatl r29, 2
+	mfdbatu r30, 3
+	mfdbatl r31, 3
+	stmw r10, 0x1e8(r2)
+	mfspr r22, 0x19
+	mfdar r23
+	mfdsisr r24
+	mfspr r25, 0x110
+	mfspr r26, 0x111
+	mfspr r27, 0x112
+	mfspr r28, 0x113
+	li r29, 0
+	mfspr r30, 0x3f2
+	mfspr r31, 0x11a
+	stmw r22, 0x25c(r2)
+	mfspr r20, 0x390
+	mfspr r21, 0x391
+	mfspr r22, 0x392
+	mfspr r23, 0x393
+	mfspr r24, 0x394
+	mfspr r25, 0x395
+	mfspr r26, 0x396
+	mfspr r27, 0x397
+	mfspr r28, 0x398
+	mfspr r29, 0x399
+	mfspr r30, 0x39a
+	mfspr r31, 0x39b
+	stmw r20, 0x2fc(r2)
+	b lbl_80371340
+	mfspr r16, 0x3a0
+	mfspr r17, 0x3a7
+	mfspr r18, 0x3a8
+	mfspr r19, 0x3a9
+	mfspr r20, 0x3aa
+	mfspr r21, 0x3ab
+	mfspr r22, 0x3ac
+	mfspr r23, 0x3ad
+	mfspr r24, 0x3ae
+	mfspr r25, 0x3af
+	mfspr r26, 0x3b0
+	mfspr r27, 0x3b7
+	mfspr r28, 0x3bf
+	mfspr r29, 0x3f6
+	mfspr r30, 0x3f7
+	mfspr r31, 0x3ff
+	stmw r16, 0x2b8(r2)
+
+lbl_80371340:
+	mfspr r19, 0x3f5
+	mfspr r20, 0x3b9
+	mfspr r21, 0x3ba
+	mfspr r22, 0x3bd
+	mfspr r23, 0x3be
+	mfspr r24, 0x3bb
+	mfspr r25, 0x3b8
+	mfspr r26, 0x3bc
+	mfspr r27, 0x3fc
+	mfspr r28, 0x3fd
+	mfspr r29, 0x3fe
+	mfspr r30, 0x3FB
+	mfspr r31, 0x3f9
+	stmw r19, 0x284(r2)
+	b end
+
+	mfspr r25, 0x3d0
+	mfspr r26, 0x3d1
+	mfspr r27, 0x3d2
+	mfspr r28, 0x3d3
+	mfspr r29, 0x3D4
+	mfspr r30, 0x3D5
+	mfspr r31, 0x3d6
+	stmw r25, 0x240(r2)
+	mfspr r31, 0x16
+	stw r31, 0x278(r2)
+end:
+	blr
+#endif // clang-format on
+}
+
+asm void TRKRestoreExtended1Block()
+{
+#ifdef __MWERKS__ // clang-format off
+	nofralloc
+	lis r2, gTRKCPUState@h /* 0x8044F338@h */
+	ori r2, r2, gTRKCPUState@l /* 0x8044F338@l */
+	lis r5, gTRKRestoreFlags@h /* 0x803D3238@h */
+	ori r5, r5, gTRKRestoreFlags@l /* 0x803D3238@l */
+	lbz r3, 0(r5)
+	lbz r6, 1(r5)
+	li r0, 0
+	stb r0, 0(r5)
+	stb r0, 1(r5)
+	cmpwi r3, 0
+	beq lbl_803713E4
+	lwz r24, 0x1e8(r2)
+	lwz r25, 0x1ec(r2)
+	mttbl r24
+	mttbu r25
+lbl_803713E4:
+	lmw r20, 0x2fc(r2)
+	mtspr 0x390, r20
+	mtspr 0x391, r21
+	mtspr 0x392, r22
+	mtspr 0x393, r23
+	mtspr 0x394, r24
+	mtspr 0x395, r25
+	mtspr 0x396, r26
+	mtspr 0x397, r27
+	mtspr 0x398, r28
+	mtspr 0x39a, r30
+	mtspr 0x39b, r31
+	b lbl_80371430
+	lmw r26, 0x2e0(r2)
+	mtspr 0x3b0, r26
+	mtspr 0x3b7, r27
+	mtspr 0x3f6, r29
+	mtspr 0x3f7, r30
+	mtspr 0x3ff, r31
+lbl_80371430:
+	lmw r19, 0x284(r2)
+	mtspr 0x3f5, r19
+	mtspr 0x3b9, r20
+	mtspr 0x3ba, r21
+	mtspr 0x3bd, r22
+	mtspr 0x3be, r23
+	mtspr 0x3bb, r24
+	mtspr 0x3b8, r25
+	mtspr 0x3bc, r26
+	mtspr 0x3fc, r27
+	mtspr 0x3fd, r28
+	mtspr 0x3fe, r29
+	mtspr 0x3FB, r30
+	mtspr 0x3f9, r31
+	b lbl_8037149C
+	cmpwi r6, 0
+	beq lbl_8037147C
+	lwz r26, 0x278(r2)
+	mtspr 0x16, r26
+lbl_8037147C:
+	lmw r25, 0x240(r2)
+	mtspr 0x3d0, r25
+	mtspr 0x3d1, r26
+	mtspr 0x3d2, r27
+	mtspr 0x3d3, r28
+	mtspr 0x3D4, r29
+	mtspr 0x3D5, r30
+	mtspr 0x3d6, r31
+lbl_8037149C:
+	lmw r16, 0x1a8(r2)
+	mtsr 0, r16
+	mtsr 1, r17
+	mtsr 2, r18
+	mtsr 3, r19
+	mtsr 4, r20
+	mtsr 5, r21
+	mtsr 6, r22
+	mtsr 7, r23
+	mtsr 8, r24
+	mtsr 9, r25
+	mtsr 0xa, r26
+	mtsr 0xb, r27
+	mtsr 0xc, r28
+	mtsr 0xd, r29
+	mtsr 0xe, r30
+	mtsr 0xf, r31
+	lmw r12, 0x1f0(r2)
+	mtspr 0x3f0, r12
+	mtspr 0x3f1, r13
+	mtspr 0x1b, r14
+	mtspr 0x11f, r15
+	mtibatu 0, r16
+	mtibatl 0, r17
+	mtibatu 1, r18
+	mtibatl 1, r19
+	mtibatu 2, r20
+	mtibatl 2, r21
+	mtibatu 3, r22
+	mtibatl 3, r23
+	mtdbatu 0, r24
+	mtdbatl 0, r25
+	mtdbatu 1, r26
+	mtdbatl 1, r27
+	mtdbatu 2, r28
+	mtdbatl 2, r29
+	mtdbatu 3, r30
+	mtdbatl 3, r31
+	lmw r22, 0x25c(r2)
+	mtspr 0x19, r22
+	mtdar r23
+	mtdsisr r24
+	mtspr 0x110, r25
+	mtspr 0x111, r26
+	mtspr 0x112, r27
+	mtspr 0x113, r28
+	mtspr 0x3f2, r30
+	mtspr 0x11a, r31
+	blr
+#endif // clang-format on
+}
+
+u32 TRKTargetCPUMinorType(void) { return 0x54; }

src/TRK_MINNOW_DOLPHIN/msg.c

@@ -0,0 +1,9 @@
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msg.h"
+#include "TRK_MINNOW_DOLPHIN/Os/dolphin/dolphin_trk_glue.h"
+#include "PowerPC_EABI_Support/MetroTRK/trk.h"
+
+DSError TRKMessageSend(TRK_Msg* msg)
+{
+	DSError write_err = TRKWriteUARTN(&msg->m_msg, msg->m_msgLength);
+	return DS_NoError;
+}

src/TRK_MINNOW_DOLPHIN/msgbuf.c

@@ -0,0 +1,359 @@
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msgbuf.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/nubinit.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mutex_TRK.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mem_TRK.h"
+#include "stddef.h"
+
+TRKBuffer gTRKMsgBufs[3];
+
+void TRKSetBufferUsed(TRKBuffer* msg, BOOL state) { msg->isInUse = state; }
+
+DSError TRKInitializeMessageBuffers(void)
+{
+	int i;
+	for (i = 0; i < 3; i++) {
+		TRKInitializeMutex(&gTRKMsgBufs[i]);
+		TRKAcquireMutex(&gTRKMsgBufs[i]);
+		TRKSetBufferUsed(&gTRKMsgBufs[i], FALSE);
+		TRKReleaseMutex(&gTRKMsgBufs[i]);
+	}
+
+	return DS_NoError;
+}
+
+DSError TRKGetFreeBuffer(int* msgID, TRKBuffer** outMsg)
+{
+	TRKBuffer* buf;
+	DSError error = DS_NoMessageBufferAvailable;
+	int i;
+
+	*outMsg = NULL;
+
+	for (i = 0; i < 3; i++) {
+		buf = TRKGetBuffer(i);
+
+		TRKAcquireMutex(buf);
+		if (!buf->isInUse) {
+			TRKResetBuffer(buf, TRUE);
+			TRKSetBufferUsed(buf, TRUE);
+			error   = DS_NoError;
+			*outMsg = buf;
+			*msgID  = i;
+			i       = 3; // why not break? weird choice
+		}
+		TRKReleaseMutex(buf);
+	}
+
+	return error;
+}
+
+void* TRKGetBuffer(int idx)
+{
+	TRKBuffer* buf = NULL;
+	if (idx >= 0 && idx < 3) {
+		buf = &gTRKMsgBufs[idx];
+	}
+
+	return buf;
+}
+
+void TRKReleaseBuffer(int idx)
+{
+	TRKBuffer* msg;
+	if (idx != -1 && idx >= 0 && idx < 3) {
+		msg = &gTRKMsgBufs[idx];
+		TRKAcquireMutex(msg);
+		TRKSetBufferUsed(msg, FALSE);
+		TRKReleaseMutex(msg);
+	}
+}
+
+void TRKResetBuffer(TRKBuffer* msg, BOOL keepData)
+{
+	msg->length   = 0;
+	msg->position = 0;
+
+	if (!keepData) {
+		TRK_memset(msg->data, 0, TRKMSGBUF_SIZE);
+	}
+}
+
+DSError TRKSetBufferPosition(TRKBuffer* msg, u32 pos)
+{
+	DSError error = DS_NoError;
+
+	if (pos > 0x880) {
+		error = DS_MessageBufferOverflow;
+	} else {
+		msg->position = pos;
+		// If the new position is past the current length,
+		// update the length
+		if (pos > msg->length) {
+			msg->length = pos;
+		}
+	}
+
+	return error;
+}
+
+DSError TRKAppendBuffer(TRKBuffer* msg, const void* data, size_t length)
+{
+	DSError error = DS_NoError; // r31
+	u32 bytesLeft;
+
+	// Return if no bytes to append
+	if (length == 0) {
+		return DS_NoError;
+	}
+
+	bytesLeft = 0x880 - msg->position;
+
+	// If there isn't enough space left in the buffer, change the number
+	// of bytes to append to the remaning number of bytes
+	if (bytesLeft < length) {
+		error  = DS_MessageBufferOverflow;
+		length = bytesLeft;
+	}
+
+	if (length == 1) {
+		// If the length of bytes to append is 1, just copy the byte over
+		msg->data[msg->position] = ((u8*)data)[0];
+	} else {
+		// Otherwise, use memcpy
+		TRK_memcpy(msg->data + msg->position, data, length);
+	}
+
+	// Update the position and length
+	msg->position += length;
+	msg->length = msg->position;
+
+	return error;
+}
+
+DSError TRKReadBuffer(TRKBuffer* msg, void* data, size_t length)
+{
+	DSError error = DS_NoError;
+	unsigned int
+	    bytesLeft; // this has to be unsigned int not u32 to match lmfao.
+
+	// Return if no bytes to read
+	if (length == 0) {
+		return DS_NoError;
+	}
+
+	bytesLeft = msg->length - msg->position;
+
+	// If the number of bytes to read exceeds the buffer length, change
+	// the length to the remaining number of bytes
+	if (length > bytesLeft) {
+		error  = DS_MessageBufferReadError;
+		length = bytesLeft;
+	}
+
+	TRK_memcpy(data, msg->data + msg->position, length);
+	msg->position += length;
+	return error;
+}
+
+DSError TRKAppendBuffer1_ui16(TRKBuffer* buffer, const u16 data)
+{
+	u8* bigEndianData;
+	u8* byteData;
+	u8 swapBuffer[sizeof(data)];
+
+	if (gTRKBigEndian) {
+		bigEndianData = (u8*)&data;
+	} else {
+		byteData      = (u8*)&data;
+		bigEndianData = swapBuffer;
+
+		bigEndianData[0] = byteData[1];
+		bigEndianData[1] = byteData[0];
+	}
+
+	return TRKAppendBuffer(buffer, (const void*)bigEndianData, sizeof(data));
+}
+
+DSError TRKAppendBuffer1_ui32(TRKBuffer* buffer, const u32 data)
+{
+	u8* bigEndianData;
+	u8* byteData;
+	u8 swapBuffer[sizeof(data)];
+
+	if (gTRKBigEndian) {
+		bigEndianData = (u8*)&data;
+	} else {
+		byteData      = (u8*)&data;
+		bigEndianData = swapBuffer;
+
+		bigEndianData[0] = byteData[3];
+		bigEndianData[1] = byteData[2];
+		bigEndianData[2] = byteData[1];
+		bigEndianData[3] = byteData[0];
+	}
+
+	return TRKAppendBuffer(buffer, (const void*)bigEndianData, sizeof(data));
+}
+
+DSError TRKAppendBuffer1_ui64(TRKBuffer* buffer, const u64 data)
+{
+	u8* bigEndianData;
+	u8* byteData;
+	u8 swapBuffer[sizeof(data)];
+	if (gTRKBigEndian) {
+		bigEndianData = (u8*)&data;
+	} else {
+		byteData      = (u8*)&data;
+		bigEndianData = swapBuffer;
+
+		bigEndianData[0] = byteData[7];
+		bigEndianData[1] = byteData[6];
+		bigEndianData[2] = byteData[5];
+		bigEndianData[3] = byteData[4];
+		bigEndianData[4] = byteData[3];
+		bigEndianData[5] = byteData[2];
+		bigEndianData[6] = byteData[1];
+		bigEndianData[7] = byteData[0];
+	}
+
+	return TRKAppendBuffer(buffer, (const void*)bigEndianData, sizeof(data));
+}
+
+DSError TRKAppendBuffer_ui8(TRKBuffer* buffer, const u8* data, int count)
+{
+	DSError err;
+	int i;
+
+	for (i = 0, err = DS_NoError; err == DS_NoError && i < count; i++) {
+		err = TRKAppendBuffer1_ui8(buffer, data[i]);
+	}
+
+	return err;
+}
+
+DSError TRKAppendBuffer_ui32(TRKBuffer* buffer, const u32* data, int count)
+{
+	DSError err;
+	int i;
+
+	for (i = 0, err = DS_NoError; err == DS_NoError && i < count; i++) {
+		err = TRKAppendBuffer1_ui32(buffer, data[i]);
+	}
+
+	return err;
+}
+
+DSError TRKReadBuffer1_ui8(TRKBuffer* buffer, u8* data)
+{
+	return TRKReadBuffer(buffer, (void*)data, 1);
+}
+
+DSError TRKReadBuffer1_ui16(TRKBuffer* buffer, u16* data)
+{
+	DSError err;
+
+	u8* bigEndianData;
+	u8* byteData;
+	u8 swapBuffer[sizeof(data)];
+
+	if (gTRKBigEndian) {
+		bigEndianData = (u8*)data;
+	} else {
+		bigEndianData = swapBuffer;
+	}
+
+	err = TRKReadBuffer(buffer, (void*)bigEndianData, sizeof(*data));
+
+	if (!gTRKBigEndian && err == DS_NoError) {
+		byteData = (u8*)data;
+
+		byteData[0] = bigEndianData[1];
+		byteData[1] = bigEndianData[0];
+	}
+
+	return err;
+}
+
+DSError TRKReadBuffer1_ui32(TRKBuffer* buffer, u32* data)
+{
+	DSError err;
+
+	u8* bigEndianData;
+	u8* byteData;
+	u8 swapBuffer[sizeof(data)];
+
+	if (gTRKBigEndian) {
+		bigEndianData = (u8*)data;
+	} else {
+		bigEndianData = swapBuffer;
+	}
+
+	err = TRKReadBuffer(buffer, (void*)bigEndianData, sizeof(*data));
+
+	if (!gTRKBigEndian && err == DS_NoError) {
+		byteData = (u8*)data;
+
+		byteData[0] = bigEndianData[3];
+		byteData[1] = bigEndianData[2];
+		byteData[2] = bigEndianData[1];
+		byteData[3] = bigEndianData[0];
+	}
+
+	return err;
+}
+
+DSError TRKReadBuffer1_ui64(TRKBuffer* buffer, u64* data)
+{
+	DSError err;
+
+	u8* bigEndianData;
+	u8* byteData;
+	u8 swapBuffer[sizeof(data)];
+
+	if (gTRKBigEndian) {
+		bigEndianData = (u8*)data;
+	} else {
+		bigEndianData = swapBuffer;
+	}
+
+	err = TRKReadBuffer(buffer, (void*)bigEndianData, sizeof(*data));
+
+	if (!gTRKBigEndian && err == 0) {
+		byteData = (u8*)data;
+
+		byteData[0] = bigEndianData[7];
+		byteData[1] = bigEndianData[6];
+		byteData[2] = bigEndianData[5];
+		byteData[3] = bigEndianData[4];
+		byteData[4] = bigEndianData[3];
+		byteData[5] = bigEndianData[2];
+		byteData[6] = bigEndianData[1];
+		byteData[7] = bigEndianData[0];
+	}
+
+	return err;
+}
+
+DSError TRKReadBuffer_ui8(TRKBuffer* buffer, u8* data, int count)
+{
+	DSError err;
+	int i;
+
+	for (i = 0, err = DS_NoError; err == DS_NoError && i < count; i++) {
+		err = TRKReadBuffer1_ui8(buffer, &(data[i]));
+	}
+
+	return err;
+}
+
+DSError TRKReadBuffer_ui32(TRKBuffer* buffer, u32* data, int count)
+{
+	DSError err;
+	s32 i;
+
+	for (i = 0, err = DS_NoError; err == DS_NoError && i < count; i++) {
+		err = TRKReadBuffer1_ui32(buffer, &(data[i]));
+	}
+
+	return err;
+}

src/TRK_MINNOW_DOLPHIN/msghndlr.c

@@ -0,0 +1,689 @@
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/nubevent.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msgbuf.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msg.h"
+#include "TRK_MINNOW_DOLPHIN/Os/dolphin/targcont.h"
+#include "TRK_MINNOW_DOLPHIN/ppc/Generic/targimpl.h"
+#include "PowerPC_EABI_Support/MetroTRK/trk.h"
+
+BOOL IsTRKConnected;
+
+BOOL GetTRKConnected()
+{
+	return IsTRKConnected;
+}
+
+void SetTRKConnected(BOOL connected)
+{
+	IsTRKConnected = connected;
+}
+
+static void TRKMessageIntoReply(TRKBuffer* buffer, u8 ackCmd,
+                                DSReplyError errSentInAck)
+{
+	TRKResetBuffer(buffer, 1);
+
+	TRKAppendBuffer1_ui8(buffer, ackCmd);
+	TRKAppendBuffer1_ui8(buffer, errSentInAck);
+}
+
+DSError TRKSendACK(TRKBuffer* buffer)
+{
+	DSError err;
+	int ackTries;
+
+	ackTries = 3;
+	do {
+		err = TRKMessageSend((TRK_Msg*)buffer);
+		--ackTries;
+	} while (err != DS_NoError && ackTries > 0);
+
+	return err;
+}
+
+DSError TRKStandardACK(TRKBuffer* buffer, MessageCommandID commandID,
+                       DSReplyError replyError)
+{
+	TRKMessageIntoReply(buffer, commandID, replyError);
+	TRKSendACK(buffer);
+	return;
+}
+
+DSError TRKDoUnsupported(TRKBuffer* buffer)
+{
+	return TRKStandardACK(buffer, DSMSG_ReplyACK,
+	                      DSREPLY_UnsupportedCommandError);
+}
+
+DSError TRKDoConnect(TRKBuffer* buffer)
+{
+	SetTRKConnected(TRUE);
+	return TRKStandardACK(buffer, DSMSG_ReplyACK, DSREPLY_NoError);
+}
+
+DSError TRKDoDisconnect(TRKBuffer* buffer)
+{
+	DSError error = DS_NoError;
+	TRKEvent event;
+	SetTRKConnected(FALSE);
+
+	if ((error = TRKStandardACK(buffer, DSMSG_ReplyACK, DSREPLY_NoError))
+	    == DS_NoError) {
+		TRKConstructEvent(&event, 1);
+		TRKPostEvent(&event);
+	}
+	return error;
+}
+
+DSError TRKDoReset(TRKBuffer* buffer)
+{
+	TRKStandardACK(buffer, DSMSG_ReplyACK, DSREPLY_NoError);
+	__TRK_reset();
+	return DS_NoError;
+}
+
+DSError TRKDoVersions(TRKBuffer* buffer)
+{
+	DSError error;
+	DSVersions versions;
+
+	if (buffer->length != 1) {
+		error = TRKStandardACK(buffer, DSMSG_ReplyACK, DSREPLY_PacketSizeError);
+	} else {
+		TRKMessageIntoReply(buffer, DSMSG_ReplyACK, DSREPLY_NoError);
+		error = TRKTargetVersions(&versions);
+
+		if (error == DS_NoError)
+			error = TRKAppendBuffer1_ui8(buffer, versions.kernelMajor);
+		if (error == DS_NoError)
+			error = TRKAppendBuffer1_ui8(buffer, versions.kernelMinor);
+		if (error == DS_NoError)
+			error = TRKAppendBuffer1_ui8(buffer, versions.protocolMajor);
+		if (error == DS_NoError)
+			error = TRKAppendBuffer1_ui8(buffer, versions.protocolMinor);
+
+		if (error != DS_NoError)
+			error = TRKStandardACK(buffer, DSMSG_ReplyACK, DSREPLY_CWDSError);
+		else
+			error = TRKSendACK(buffer);
+	}
+	return error;
+}
+
+DSError TRKDoSupportMask(TRKBuffer* buffer)
+{
+	DSError error;
+	u8 mask[32];
+
+	if (buffer->length != 1) {
+		TRKStandardACK(buffer, DSMSG_ReplyACK, DSREPLY_PacketSizeError);
+	} else {
+		TRKMessageIntoReply(buffer, DSMSG_ReplyACK, DSREPLY_NoError);
+		error = TRKTargetSupportMask(mask);
+
+		if (error == DS_NoError)
+			error = TRKAppendBuffer(buffer, mask, 32);
+		if (error == DS_NoError)
+			error = TRKAppendBuffer1_ui8(buffer, 2);
+
+		if (error != DS_NoError)
+			TRKStandardACK(buffer, DSMSG_ReplyACK, DSREPLY_CWDSError);
+		else
+			TRKSendACK(buffer);
+	}
+}
+
+DSError TRKDoCPUType(TRKBuffer* buffer)
+{
+	DSError error;
+	DSCPUType cputype;
+
+	if (buffer->length != 1) {
+		error = TRKStandardACK(buffer, DSMSG_ReplyACK, DSREPLY_PacketSizeError);
+		return error;
+	}
+
+	TRKMessageIntoReply(buffer, DSMSG_ReplyACK, DSREPLY_NoError);
+
+	error = TRKTargetCPUType(&cputype);
+
+	if (error == DS_NoError)
+		error = TRKAppendBuffer1_ui8(buffer, cputype.cpuMajor);
+	if (error == DS_NoError)
+		error = TRKAppendBuffer1_ui8(buffer, cputype.cpuMinor);
+	if (error == DS_NoError)
+		error = TRKAppendBuffer1_ui8(buffer, cputype.bigEndian);
+	if (error == DS_NoError)
+		error = TRKAppendBuffer1_ui8(buffer, cputype.defaultTypeSize);
+	if (error == DS_NoError)
+		error = TRKAppendBuffer1_ui8(buffer, cputype.fpTypeSize);
+	if (error == DS_NoError)
+		error = TRKAppendBuffer1_ui8(buffer, cputype.extended1TypeSize);
+	if (error == DS_NoError)
+		error = TRKAppendBuffer1_ui8(buffer, cputype.extended2TypeSize);
+
+	if (error != DS_NoError)
+		error = TRKStandardACK(buffer, DSMSG_ReplyACK, DSREPLY_CWDSError);
+	else
+		error = TRKSendACK(buffer);
+
+	return error;
+}
+
+DSError TRKDoReadMemory(TRKBuffer* buffer)
+{
+	DSError error;
+	DSReplyError replyError;
+	u8 tempBuf[0x800];
+	u32 length;
+	u32 msg_start;
+	u16 msg_length;
+	u8 msg_options;
+	u8 msg_command;
+
+	if (buffer->length != 8) {
+		error = TRKStandardACK(buffer, DSMSG_ReplyACK, DSREPLY_PacketSizeError);
+		return error;
+	}
+
+	TRKSetBufferPosition(buffer, DSREPLY_NoError);
+	error = TRKReadBuffer1_ui8(buffer, &msg_command);
+	if (error == DS_NoError)
+		error = TRKReadBuffer1_ui8(buffer, &msg_options);
+
+	if (error == DS_NoError)
+		error = TRKReadBuffer1_ui16(buffer, &msg_length);
+
+	if (error == DS_NoError)
+		error = TRKReadBuffer1_ui32(buffer, &msg_start);
+
+	if (msg_options & 2) {
+		error = TRKStandardACK(buffer, DSMSG_ReplyACK,
+		                       DSREPLY_UnsupportedOptionError);
+		return error;
+	}
+
+	if (msg_length > 0x800) {
+		error = TRKStandardACK(buffer, DSMSG_ReplyACK, DSREPLY_ParameterError);
+		return error;
+	}
+
+	TRKMessageIntoReply(buffer, DSMSG_ReplyACK, DSREPLY_NoError);
+
+	if (error == DS_NoError) {
+		length = (u32)msg_length;
+		error  = TRKTargetAccessMemory(
+            tempBuf, msg_start, &length,
+            (msg_options & 8) ? MEMACCESS_UserMemory : MEMACCESS_DebuggerMemory,
+            1);
+		msg_length = (u16)length;
+		if (error == DS_NoError)
+			error = TRKAppendBuffer1_ui16(buffer, msg_length);
+		if (error == DS_NoError)
+			error = TRKAppendBuffer(buffer, tempBuf, length);
+	}
+
+	if (error != DS_NoError) {
+		switch (error) {
+		case DS_CWDSException:
+			replyError = DSREPLY_CWDSException;
+			break;
+		case DS_InvalidMemory:
+			replyError = DSREPLY_InvalidMemoryRange;
+			break;
+		case DS_InvalidProcessID:
+			replyError = DSREPLY_InvalidProcessID;
+			break;
+		case DS_InvalidThreadID:
+			replyError = DSREPLY_InvalidThreadID;
+			break;
+		case DS_OSError:
+			replyError = DSREPLY_OSError;
+			break;
+		default:
+			replyError = DSREPLY_CWDSError;
+			break;
+		}
+		error = TRKStandardACK(buffer, DSMSG_ReplyACK, replyError);
+	} else {
+		error = TRKSendACK(buffer);
+	}
+
+	return error;
+}
+
+DSError TRKDoWriteMemory(TRKBuffer* buffer)
+{
+	DSError error;
+	DSReplyError replyError;
+	u8 tmpBuffer[0x800];
+	u32 length;
+	u32 msg_start;
+	u16 msg_length;
+	u8 msg_options;
+	u8 msg_command;
+
+	if (buffer->length <= 8) {
+		error = TRKStandardACK(buffer, DSMSG_ReplyACK, DSREPLY_PacketSizeError);
+		return error;
+	}
+
+	TRKSetBufferPosition(buffer, DSREPLY_NoError);
+	error = TRKReadBuffer1_ui8(buffer, &msg_command);
+	if (error == DS_NoError)
+		error = TRKReadBuffer1_ui8(buffer, &msg_options);
+
+	if (error == DS_NoError)
+		error = TRKReadBuffer1_ui16(buffer, &msg_length);
+
+	if (error == DS_NoError)
+		error = TRKReadBuffer1_ui32(buffer, &msg_start);
+
+	if (msg_options & 2) {
+		error = TRKStandardACK(buffer, DSMSG_ReplyACK,
+		                       DSREPLY_UnsupportedOptionError);
+		return error;
+	}
+
+	if ((buffer->length != msg_length + 8) || (msg_length > 0x800)) {
+		error = TRKStandardACK(buffer, DSMSG_ReplyACK, DSREPLY_ParameterError);
+	} else {
+		if (error == DS_NoError) {
+			length = (u32)msg_length;
+			error  = TRKReadBuffer(buffer, tmpBuffer, length);
+			if (error == DS_NoError) {
+				error = TRKTargetAccessMemory(tmpBuffer, msg_start, &length,
+				                              (msg_options & 8)
+				                                  ? MEMACCESS_UserMemory
+				                                  : MEMACCESS_DebuggerMemory,
+				                              FALSE);
+			}
+			msg_length = (u16)length;
+		}
+
+		if (error == DS_NoError)
+			TRKMessageIntoReply(buffer, DSMSG_ReplyACK, DSREPLY_NoError);
+
+		if (error == DS_NoError)
+			error = TRKAppendBuffer1_ui16(buffer, msg_length);
+
+		if (error != DS_NoError) {
+			switch (error) {
+			case DS_CWDSException:
+				replyError = DSREPLY_CWDSException;
+				break;
+			case DS_InvalidMemory:
+				replyError = DSREPLY_InvalidMemoryRange;
+				break;
+			case DS_InvalidProcessID:
+				replyError = DSREPLY_InvalidProcessID;
+				break;
+			case DS_InvalidThreadID:
+				replyError = DSREPLY_InvalidThreadID;
+				break;
+			case DS_OSError:
+				replyError = DSREPLY_OSError;
+				break;
+			default:
+				replyError = DSREPLY_CWDSError;
+				break;
+			}
+			error = TRKStandardACK(buffer, DSMSG_ReplyACK, replyError);
+		} else {
+			error = TRKSendACK(buffer);
+		}
+	}
+
+	return error;
+}
+
+DSError TRKDoReadRegisters(TRKBuffer* buffer)
+{
+	DSError error;
+	DSReplyError replyError;
+	DSMessageRegisterOptions options;
+	u32 registerDataLength;
+	u16 msg_lastRegister;
+	u16 msg_firstRegister;
+	u8 msg_options;
+	u8 msg_command;
+
+	if (buffer->length != 6) {
+		error = TRKStandardACK(buffer, DSMSG_ReplyACK, DSREPLY_PacketSizeError);
+		return error;
+	}
+	TRKSetBufferPosition(buffer, DSREPLY_NoError);
+	error = TRKReadBuffer1_ui8(buffer, &msg_command);
+	if (error == DS_NoError)
+		error = TRKReadBuffer1_ui8(buffer, &msg_options);
+
+	if (error == DS_NoError)
+		error = TRKReadBuffer1_ui16(buffer, &msg_firstRegister);
+
+	if (error == DS_NoError)
+		error = TRKReadBuffer1_ui16(buffer, &msg_lastRegister);
+
+	if (msg_firstRegister > msg_lastRegister) {
+		error = TRKStandardACK(buffer, DSMSG_ReplyACK,
+		                       DSREPLY_InvalidRegisterRange);
+		return error;
+	}
+
+	if (error == DS_NoError)
+		TRKMessageIntoReply(buffer, DSMSG_ReplyACK, DSREPLY_NoError);
+
+	options = (DSMessageRegisterOptions)msg_options;
+	switch (options) {
+	case DSREG_Default:
+		error = TRKTargetAccessDefault(msg_firstRegister, msg_lastRegister,
+		                               buffer, &registerDataLength, TRUE);
+		break;
+	case DSREG_FP:
+		error = TRKTargetAccessFP(msg_firstRegister, msg_lastRegister, buffer,
+		                          &registerDataLength, TRUE);
+		break;
+	case DSREG_Extended1:
+		error = TRKTargetAccessExtended1(msg_firstRegister, msg_lastRegister,
+		                                 buffer, &registerDataLength, TRUE);
+		break;
+	case DSREG_Extended2:
+		error = TRKTargetAccessExtended2(msg_firstRegister, msg_lastRegister,
+		                                 buffer, &registerDataLength, TRUE);
+		break;
+	default:
+		error = DS_UnsupportedError;
+		break;
+	}
+
+	if (error != DS_NoError) {
+		switch (error) {
+		case DS_UnsupportedError:
+			replyError = DSREPLY_UnsupportedOptionError;
+			break;
+		case DS_InvalidRegister:
+			replyError = DSREPLY_InvalidRegisterRange;
+			break;
+		case DS_CWDSException:
+			replyError = DSREPLY_CWDSException;
+			break;
+		case DS_InvalidProcessID:
+			replyError = DSREPLY_InvalidProcessID;
+			break;
+		case DS_InvalidThreadID:
+			replyError = DSREPLY_InvalidThreadID;
+			break;
+		case DS_OSError:
+			replyError = DSREPLY_OSError;
+			break;
+		default:
+			replyError = DSREPLY_CWDSError;
+		}
+
+		error = TRKStandardACK(buffer, DSMSG_ReplyACK, replyError);
+	} else {
+		error = TRKSendACK(buffer);
+	}
+
+	return error;
+}
+
+DSError TRKDoWriteRegisters(TRKBuffer* buffer)
+{
+	DSError error;
+	DSReplyError replyError;
+	DSMessageRegisterOptions options;
+	u32 registerDataLength;
+	u16 msg_lastRegister;
+	u16 msg_firstRegister;
+	u8 msg_options;
+	u8 msg_command;
+
+	if (buffer->length <= 6) {
+		error = TRKStandardACK(buffer, DSMSG_ReplyACK, DSREPLY_PacketSizeError);
+		return error;
+	}
+	TRKSetBufferPosition(buffer, DSREPLY_NoError);
+	error = TRKReadBuffer1_ui8(buffer, &msg_command);
+	if (error == DS_NoError)
+		error = TRKReadBuffer1_ui8(buffer, &msg_options);
+
+	if (error == DS_NoError)
+		error = TRKReadBuffer1_ui16(buffer, &msg_firstRegister);
+
+	if (error == DS_NoError)
+		error = TRKReadBuffer1_ui16(buffer, &msg_lastRegister);
+
+	if (msg_firstRegister > msg_lastRegister) {
+		error = TRKStandardACK(buffer, DSMSG_ReplyACK,
+		                       DSREPLY_InvalidRegisterRange);
+		return error;
+	}
+
+	options = (DSMessageRegisterOptions)msg_options;
+	switch (options) {
+	case DSREG_Default:
+		error = TRKTargetAccessDefault(msg_firstRegister, msg_lastRegister,
+		                               buffer, &registerDataLength, FALSE);
+		break;
+	case DSREG_FP:
+		error = TRKTargetAccessFP(msg_firstRegister, msg_lastRegister, buffer,
+		                          &registerDataLength, FALSE);
+		break;
+	case DSREG_Extended1:
+		error = TRKTargetAccessExtended1(msg_firstRegister, msg_lastRegister,
+		                                 buffer, &registerDataLength, FALSE);
+		break;
+	case DSREG_Extended2:
+		error = TRKTargetAccessExtended2(msg_firstRegister, msg_lastRegister,
+		                                 buffer, &registerDataLength, FALSE);
+		break;
+	default:
+		error = DS_UnsupportedError;
+		break;
+	}
+
+	if (error == DS_NoError)
+		TRKMessageIntoReply(buffer, DSMSG_ReplyACK, DSREPLY_NoError);
+
+	if (error != DS_NoError) {
+		switch (error) {
+		case DS_UnsupportedError:
+			replyError = DSREPLY_UnsupportedOptionError;
+			break;
+		case DS_InvalidRegister:
+			replyError = DSREPLY_InvalidRegisterRange;
+			break;
+		case DS_MessageBufferReadError:
+			replyError = DSREPLY_PacketSizeError;
+			break;
+		case DS_CWDSException:
+			replyError = DSREPLY_CWDSException;
+			break;
+		case DS_InvalidProcessID:
+			replyError = DSREPLY_InvalidProcessID;
+			break;
+		case DS_InvalidThreadID:
+			replyError = DSREPLY_InvalidThreadID;
+			break;
+		case DS_OSError:
+			replyError = DSREPLY_OSError;
+			break;
+		default:
+			replyError = DSREPLY_CWDSError;
+		}
+
+		error = TRKStandardACK(buffer, DSMSG_ReplyACK, replyError);
+	} else {
+		error = TRKSendACK(buffer);
+	}
+
+	return error;
+}
+
+DSError TRKDoFlushCache(TRKBuffer* buffer)
+{
+	DSError error;
+	DSReplyError replyErr;
+	u32 msg_end;
+	u32 msg_start;
+	u8 msg_options;
+	u8 msg_command;
+
+	if (buffer->length != 10) {
+		error = TRKStandardACK(buffer, DSMSG_ReplyACK, DSREPLY_PacketSizeError);
+		return error;
+	}
+
+	TRKSetBufferPosition(buffer, DSREPLY_NoError);
+	error = TRKReadBuffer1_ui8(buffer, &msg_command);
+	if (error == DS_NoError)
+		error = TRKReadBuffer1_ui8(buffer, &msg_options);
+	if (error == DS_NoError)
+		error = TRKReadBuffer1_ui32(buffer, &msg_start);
+	if (error == DS_NoError)
+		error = TRKReadBuffer1_ui32(buffer, &msg_end);
+
+	if (msg_start > msg_end) {
+		error = TRKStandardACK(buffer, DSMSG_ReplyACK,
+		                       DSREPLY_InvalidMemoryRange);
+		return error;
+	}
+
+	if (error == DS_NoError)
+		error = TRKTargetFlushCache(msg_options, (void*)msg_start,
+		                            (void*)msg_end);
+
+	if (error == DS_NoError)
+		TRKMessageIntoReply(buffer, DSMSG_ReplyACK, DSREPLY_NoError);
+
+	if (error != DS_NoError) {
+		switch (error) {
+		case DS_UnsupportedError:
+			replyErr = DSREPLY_UnsupportedOptionError;
+			break;
+		default:
+			replyErr = DSREPLY_CWDSError;
+			break;
+		}
+
+		error = TRKStandardACK(buffer, DSMSG_ReplyACK, replyErr);
+	} else {
+		error = TRKSendACK(buffer);
+	}
+
+	return error;
+}
+
+DSError TRKDoContinue(TRKBuffer* buffer)
+{
+	DSError error;
+
+	error = TRKTargetStopped();
+	if (error == DS_NoError) {
+		error = TRKStandardACK(buffer, DSMSG_ReplyACK, DSREPLY_NotStopped);
+		return error;
+	}
+
+	error = TRKStandardACK(buffer, DSMSG_ReplyACK, DSREPLY_NoError);
+	if (error == DS_NoError)
+		error = TRKTargetContinue();
+
+	return error;
+}
+
+DSError TRKDoStep(TRKBuffer* buffer)
+{
+	DSError error;
+	u8 msg_command;
+	u8 msg_options;
+	u8 msg_count;
+	u32 msg_rangeStart;
+	u32 msg_rangeEnd;
+	u32 pc;
+
+	if (buffer->length < 3)
+		return TRKStandardACK(buffer, DSMSG_ReplyACK, DSREPLY_PacketSizeError);
+
+	TRKSetBufferPosition(buffer, DSREPLY_NoError);
+
+	error = TRKReadBuffer1_ui8(buffer, &msg_command);
+	if (error == DS_NoError)
+		error = TRKReadBuffer1_ui8(buffer, &msg_options);
+
+	switch (msg_options) {
+	case DSSTEP_IntoCount:
+	case DSSTEP_OverCount:
+		if (error == DS_NoError)
+			TRKReadBuffer1_ui8(buffer, &msg_count);
+		if (msg_count >= 1) {
+			break;
+		}
+		return TRKStandardACK(buffer, DSMSG_ReplyACK, DSREPLY_ParameterError);
+	case DSSTEP_IntoRange:
+	case DSSTEP_OverRange:
+		if (buffer->length != 10)
+			return TRKStandardACK(buffer, DSMSG_ReplyACK,
+			                      DSREPLY_PacketSizeError);
+
+		if (error == DS_NoError)
+			error = TRKReadBuffer1_ui32(buffer, &msg_rangeStart);
+		if (error == DS_NoError)
+			error = TRKReadBuffer1_ui32(buffer, &msg_rangeEnd);
+
+		pc = TRKTargetGetPC();
+		if (pc >= msg_rangeStart && pc <= msg_rangeEnd) {
+			break;
+		}
+		return TRKStandardACK(buffer, DSMSG_ReplyACK, DSREPLY_ParameterError);
+	default:
+		return TRKStandardACK(buffer, DSMSG_ReplyACK,
+		                      DSREPLY_UnsupportedOptionError);
+	}
+
+	if (!TRKTargetStopped()) {
+		return TRKStandardACK(buffer, DSMSG_ReplyACK, DSREPLY_NotStopped);
+	} else {
+		error = TRKStandardACK(buffer, DSMSG_ReplyACK, DSREPLY_NoError);
+		if (error == DS_NoError)
+			switch (msg_options) {
+			case DSSTEP_IntoCount:
+			case DSSTEP_OverCount:
+				error = TRKTargetSingleStep(msg_count,
+				                            (msg_options == DSSTEP_OverCount));
+				break;
+			case DSSTEP_IntoRange:
+			case DSSTEP_OverRange:
+				error = TRKTargetStepOutOfRange(
+				    msg_rangeStart, msg_rangeEnd,
+				    (msg_options == DSSTEP_OverRange));
+				break;
+			}
+
+		return error;
+	}
+}
+
+DSError TRKDoStop(TRKBuffer* b)
+{
+	DSReplyError replyError;
+
+	switch (TRKTargetStop()) {
+	case DS_NoError:
+		replyError = DSREPLY_NoError;
+		break;
+	case DS_InvalidProcessID:
+		replyError = DSREPLY_InvalidProcessID;
+		break;
+	case DS_InvalidThreadID:
+		replyError = DSREPLY_InvalidThreadID;
+		break;
+	case DS_OSError:
+		replyError = DSREPLY_OSError;
+		break;
+	default:
+		replyError = DSREPLY_Error;
+		break;
+	}
+
+	return TRKStandardACK(b, DSMSG_ReplyACK, replyError);
+}

src/TRK_MINNOW_DOLPHIN/mutex_TRK.c

@@ -0,0 +1,7 @@
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mutex_TRK.h"
+
+DSError TRKInitializeMutex(void*) { return DS_NoError; }
+
+DSError TRKAcquireMutex(void*) { return DS_NoError; }
+
+DSError TRKReleaseMutex(void*) { return DS_NoError; }

src/TRK_MINNOW_DOLPHIN/notify.c

@@ -0,0 +1,40 @@
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/notify.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msgbuf.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/support.h"
+#include "TRK_MINNOW_DOLPHIN/ppc/Generic/targimpl.h"
+#include "PowerPC_EABI_Support/MetroTRK/trk.h"
+
+DSError TRKDoNotifyStopped(MessageCommandID cmd)
+{
+	DSError err;
+	int reqIdx;
+	int bufIdx;
+	TRKBuffer* msg;
+
+	err = TRKGetFreeBuffer(&bufIdx, &msg);
+	if (err == DS_NoError) {
+		if (msg->position >= 0x880) {
+			err = DS_MessageBufferOverflow;
+		} else {
+			msg->data[msg->position++] = cmd;
+			++msg->length;
+			err = 0;
+		}
+
+		if (err == DS_NoError) {
+			if (cmd == DSMSG_NotifyStopped) {
+				TRKTargetAddStopInfo(msg);
+			} else {
+				TRKTargetAddExceptionInfo(msg);
+			}
+		}
+
+		err = TRKRequestSend(msg, &reqIdx, 2, 3, 1);
+		if (err == DS_NoError) {
+			TRKReleaseBuffer(reqIdx);
+		}
+		TRKReleaseBuffer(bufIdx);
+	}
+
+	return err;
+}

src/TRK_MINNOW_DOLPHIN/nubevent.c

@@ -0,0 +1,72 @@
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/nubevent.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mutex_TRK.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msgbuf.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mem_TRK.h"
+
+TRKEventQueue gTRKEventQueue;
+
+DSError TRKInitializeEventQueue()
+{
+	TRKInitializeMutex(&gTRKEventQueue);
+	TRKAcquireMutex(&gTRKEventQueue);
+	gTRKEventQueue.count   = 0;
+	gTRKEventQueue.next    = 0;
+	gTRKEventQueue.eventID = 0x100;
+	TRKReleaseMutex(&gTRKEventQueue);
+	return DS_NoError;
+}
+
+void TRKCopyEvent(TRKEvent* dstEvent, const TRKEvent* srcEvent)
+{
+	TRK_memcpy(dstEvent, srcEvent, sizeof(TRKEvent));
+}
+
+BOOL TRKGetNextEvent(TRKEvent* event)
+{
+	BOOL status = 0;
+	TRKAcquireMutex(&gTRKEventQueue);
+	if (0 < gTRKEventQueue.count) {
+		TRKCopyEvent(event, &gTRKEventQueue.events[gTRKEventQueue.next]);
+		gTRKEventQueue.count--;
+		gTRKEventQueue.next++;
+		if (gTRKEventQueue.next == 2)
+			gTRKEventQueue.next = 0;
+
+		status = 1;
+	}
+	TRKReleaseMutex(&gTRKEventQueue);
+	return status;
+}
+
+DSError TRKPostEvent(TRKEvent* event)
+{
+	DSError ret = DS_NoError;
+	int nextEventID;
+
+	TRKAcquireMutex(&gTRKEventQueue);
+
+	if (gTRKEventQueue.count == 2) {
+		ret = DS_EventQueueFull;
+	} else {
+		nextEventID = (gTRKEventQueue.next + gTRKEventQueue.count) % 2;
+		TRKCopyEvent(&gTRKEventQueue.events[nextEventID], event);
+		gTRKEventQueue.events[nextEventID].eventID = gTRKEventQueue.eventID;
+		gTRKEventQueue.eventID++;
+		if (gTRKEventQueue.eventID < 0x100)
+			gTRKEventQueue.eventID = 0x100;
+
+		gTRKEventQueue.count++;
+	}
+
+	TRKReleaseMutex(&gTRKEventQueue);
+	return ret;
+}
+
+void TRKConstructEvent(TRKEvent* event, NubEventType eventType)
+{
+	event->eventType = eventType;
+	event->eventID   = 0;
+	event->msgBufID  = -1;
+}
+
+void TRKDestructEvent(TRKEvent* event) { TRKReleaseBuffer(event->msgBufID); }

src/TRK_MINNOW_DOLPHIN/nubinit.c

@@ -0,0 +1,80 @@
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/nubinit.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/nubevent.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msgbuf.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/serpoll.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/dispatch.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/serpoll.h"
+#include "TRK_MINNOW_DOLPHIN/Os/dolphin/dolphin_trk.h"
+#include "TRK_MINNOW_DOLPHIN/Os/dolphin/dolphin_trk_glue.h"
+#include "TRK_MINNOW_DOLPHIN/Os/dolphin/usr_put.h"
+#include "TRK_MINNOW_DOLPHIN/ppc/Generic/targimpl.h"
+
+BOOL gTRKBigEndian;
+
+BOOL TRKInitializeEndian(void);
+
+DSError TRKInitializeNub(void)
+{
+	DSError ret;
+	DSError uartErr;
+
+	ret = TRKInitializeEndian();
+
+	if (ret == DS_NoError)
+		usr_put_initialize();
+	if (ret == DS_NoError)
+		ret = TRKInitializeEventQueue();
+	if (ret == DS_NoError)
+		ret = TRKInitializeMessageBuffers();
+	if (ret == DS_NoError)
+		ret = TRKInitializeDispatcher();
+
+	if (ret == DS_NoError) {
+		uartErr = TRKInitializeIntDrivenUART(0x0000e100, 1, 0,
+		                                     (volatile u8**)&gTRKInputPendingPtr);
+		TRKTargetSetInputPendingPtr(gTRKInputPendingPtr);
+		if (uartErr != DS_NoError) {
+			ret = uartErr;
+		}
+	}
+
+	if (ret == DS_NoError)
+		ret = TRKInitializeSerialHandler();
+	if (ret == DS_NoError)
+		ret = TRKInitializeTarget();
+
+	return ret;
+}
+
+DSError TRKTerminateNub(void)
+{
+	TRKTerminateSerialHandler();
+	return DS_NoError;
+}
+
+void TRKNubWelcome(void)
+{
+	TRK_board_display("MetroTRK for GAMECUBE v0.10");
+	return;
+}
+
+BOOL TRKInitializeEndian(void)
+{
+	u8 bendian[4];
+	BOOL result   = FALSE;
+	gTRKBigEndian = TRUE;
+
+	bendian[0] = 0x12;
+	bendian[1] = 0x34;
+	bendian[2] = 0x56;
+	bendian[3] = 0x78;
+
+	if (*(u32*)bendian == 0x12345678) {
+		gTRKBigEndian = TRUE;
+	} else if (*(u32*)bendian == 0x78563412) {
+		gTRKBigEndian = FALSE;
+	} else {
+		result = TRUE;
+	}
+	return result;
+}

src/TRK_MINNOW_DOLPHIN/serpoll.c

@@ -0,0 +1,82 @@
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/serpoll.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/nubevent.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msgbuf.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr.h"
+#include "TRK_MINNOW_DOLPHIN/Os/dolphin/dolphin_trk_glue.h"
+#include "PowerPC_EABI_Support/MetroTRK/trk.h"
+
+static TRKFramingState gTRKFramingState;
+
+void* gTRKInputPendingPtr;
+
+MessageBufferID TRKTestForPacket()
+{
+	int bytes;
+	int batch;
+	int err;
+	TRKBuffer* b;
+	int id;
+
+	bytes = TRKPollUART();
+	if (bytes > 0) {
+		TRKGetFreeBuffer(&id, &b);
+		if (bytes > TRKMSGBUF_SIZE) {
+			for (; bytes > 0; bytes -= batch) {
+				batch = bytes > TRKMSGBUF_SIZE ? TRKMSGBUF_SIZE : bytes;
+				TRKReadUARTN(b->data, batch);
+			}
+			TRKStandardACK(b, 0xff, 6);
+		} else {
+			err = TRKReadUARTN(b->data, bytes);
+			if (err == 0) {
+				b->length = bytes;
+				return id;
+			}
+		}
+	}
+	if (id != -1) {
+		TRKReleaseBuffer(id);
+	}
+	return -1;
+}
+
+void TRKGetInput(void)
+{
+	MessageBufferID id;
+	TRKBuffer* msgBuffer;
+	u8 command;
+
+	id = TRKTestForPacket();
+	if (id == -1)
+		return;
+
+	msgBuffer = TRKGetBuffer(id);
+	TRKSetBufferPosition(msgBuffer, 0);
+	TRKReadBuffer1_ui8(msgBuffer, &command);
+	if (command < DSMSG_ReplyACK) {
+		TRKProcessInput(id);
+	} else {
+		TRKReleaseBuffer(id);
+	}
+}
+
+void TRKProcessInput(int bufferIdx)
+{
+	TRKEvent event;
+
+	TRKConstructEvent(&event, NUBEVENT_Request);
+	gTRKFramingState.msgBufID = -1;
+	event.msgBufID            = bufferIdx;
+	TRKPostEvent(&event);
+}
+
+DSError TRKInitializeSerialHandler(void)
+{
+	gTRKFramingState.msgBufID     = -1;
+	gTRKFramingState.receiveState = DSRECV_Wait;
+	gTRKFramingState.isEscape     = FALSE;
+
+	return DS_NoError;
+}
+
+DSError TRKTerminateSerialHandler(void) { return DS_NoError; }

src/TRK_MINNOW_DOLPHIN/support.c

@@ -0,0 +1,177 @@
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/support.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msgbuf.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msg.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/serpoll.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr.h"
+#include "stddef.h"
+#include "string.h"
+
+DSError TRKSuppAccessFile(u32 file_handle, u8* data, size_t* count,
+                          DSIOResult* io_result, BOOL need_reply, BOOL read)
+{
+	DSError error;
+	int replyBufferId;
+	TRKBuffer* replyBuffer;
+	int bufferId;
+	TRKBuffer* buffer;
+	u32 length;
+	u32 done;
+	u8 replyIOResult;
+	u16 replyLength;
+	BOOL exit;
+
+	if (data == NULL || *count == 0) {
+		return DS_ParameterError;
+	}
+
+	exit       = FALSE;
+	*io_result = DS_IONoError;
+	done       = 0;
+	error      = DS_NoError;
+	while (!exit && done < *count && error == DS_NoError && *io_result == 0) {
+		if (*count - done > 0x800) {
+			length = 0x800;
+		} else {
+			length = *count - done;
+		}
+
+		error = TRKGetFreeBuffer(&bufferId, &buffer);
+
+		if (error == DS_NoError)
+			error = TRKAppendBuffer1_ui8(buffer, read ? DSMSG_ReadFile
+			                                          : DSMSG_WriteFile);
+
+		if (error == DS_NoError)
+			error = TRKAppendBuffer1_ui32(buffer, file_handle);
+
+		if (error == DS_NoError)
+			error = TRKAppendBuffer1_ui16(buffer, length);
+
+		if (!read && error == DS_NoError)
+			error = TRKAppendBuffer_ui8(buffer, data + done, length);
+
+		if (error == DS_NoError) {
+			if (need_reply) {
+				replyLength   = 0;
+				replyIOResult = 0;
+
+				error = TRKRequestSend(buffer, &replyBufferId, read ? 5 : 5, 3,
+				                       !(read && file_handle == 0));
+				if (error == DS_NoError) {
+					replyBuffer = (TRKBuffer*)TRKGetBuffer(replyBufferId);
+					TRKSetBufferPosition(replyBuffer, 2);
+				}
+
+				if (error == DS_NoError)
+					error = TRKReadBuffer1_ui8(replyBuffer, &replyIOResult);
+
+				if (error == DS_NoError)
+					error = TRKReadBuffer1_ui16(replyBuffer, &replyLength);
+
+				if (read && error == DS_NoError) {
+					if (replyBuffer->length != replyLength + 5) {
+						replyLength = replyBuffer->length - 5;
+						if (replyIOResult == 0)
+							replyIOResult = 1;
+					}
+
+					if (replyLength <= length)
+						error = TRKReadBuffer_ui8(replyBuffer, data + done,
+						                          replyLength);
+				}
+
+				if (replyLength != length) {
+					if ((!read || replyLength >= length) && replyIOResult == 0)
+						replyIOResult = 1;
+					length = replyLength;
+					exit   = TRUE;
+				}
+
+				*io_result = (DSIOResult)replyIOResult;
+				TRKReleaseBuffer(replyBufferId);
+			} else {
+				error = TRKMessageSend((TRK_Msg*)buffer);
+			}
+		}
+
+		TRKReleaseBuffer(bufferId);
+		done += length;
+	}
+
+	*count = done;
+	return error;
+}
+
+DSError TRKRequestSend(TRKBuffer* msgBuf, int* bufferId, u32 p1, u32 p2, int p3)
+{
+	int error = DS_NoError;
+	TRKBuffer* buffer;
+	u32 timer;
+	int tries;
+	u8 msg_command;
+	u8 msg_error;
+	BOOL badReply = TRUE;
+
+	*bufferId = -1;
+
+	for (tries = p2 + 1; tries != 0 && *bufferId == -1 && error == DS_NoError;
+	     tries--) {
+		error = TRKMessageSend((TRK_Msg*)msgBuf);
+		if (error == DS_NoError) {
+			if (p3) {
+				timer = 0;
+			}
+
+			while (TRUE) {
+				do {
+					*bufferId = TRKTestForPacket();
+					if (*bufferId != -1)
+						break;
+				} while (!p3 || ++timer < 79999980);
+
+				if (*bufferId == -1)
+					break;
+
+				badReply = FALSE;
+
+				buffer = TRKGetBuffer(*bufferId);
+				TRKSetBufferPosition(buffer, 0);
+
+				if ((error = TRKReadBuffer1_ui8(buffer, &msg_command))
+				    != DS_NoError)
+					break;
+
+				if (msg_command >= DSMSG_ReplyACK)
+					break;
+
+				TRKProcessInput(*bufferId);
+				*bufferId = -1;
+			}
+
+			if (*bufferId != -1) {
+				if (buffer->length < p1) {
+					badReply = TRUE;
+				}
+				if (error == DS_NoError && !badReply) {
+					error = TRKReadBuffer1_ui8(buffer, &msg_error);
+				}
+				if (error == DS_NoError && !badReply) {
+					if (msg_command != DSMSG_ReplyACK
+					    || msg_error != DSREPLY_NoError) {
+						badReply = TRUE;
+					}
+				}
+				if (error != DS_NoError || badReply) {
+					TRKReleaseBuffer(*bufferId);
+					*bufferId = -1;
+				}
+			}
+		}
+	}
+
+	if (*bufferId == -1) {
+		error = DS_Error800;
+	}
+
+	return error;
+}

src/TRK_MINNOW_DOLPHIN/targcont.c

@@ -0,0 +1,12 @@
+#include "TRK_MINNOW_DOLPHIN/Os/dolphin/targcont.h"
+#include "TRK_MINNOW_DOLPHIN/Os/dolphin/dolphin_trk_glue.h"
+#include "TRK_MINNOW_DOLPHIN/ppc/Generic/targimpl.h"
+
+DSError TRKTargetContinue(void)
+{
+	TRKTargetSetStopped(0);
+	UnreserveEXI2Port();
+	TRKSwapAndGo();
+	ReserveEXI2Port();
+	return 0;
+}

src/TRK_MINNOW_DOLPHIN/usr_put.c

@@ -0,0 +1,5 @@
+#include "TRK_MINNOW_DOLPHIN/Os/dolphin/usr_put.h"
+#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr.h"
+#include "PowerPC_EABI_Support/MetroTRK/trk.h"
+
+void usr_put_initialize(void) { }