Created solution for testing output

test/portultra/ultra64.h

@@ -0,0 +1,133 @@
+#ifndef __ULTRA64_MULTILIBULTRA_H__
+#define __ULTRA64_MULTILIBULTRA_H__
+
+#include <stdint.h>
+#include "platform_specific.h"
+
+#ifdef __cplusplus
+#include <queue>
+#endif
+
+#ifdef __GNUC__
+#define UNUSED __attribute__((unused))
+#define ALIGNED(x) __attribute__((aligned(x)))
+#else
+#define UNUSED
+#define ALIGNED(x)
+#endif
+
+typedef int64_t s64;
+typedef uint64_t u64;
+typedef int32_t s32;
+typedef uint32_t u32;
+typedef int16_t s16;
+typedef uint16_t u16;
+typedef int8_t s8;
+typedef uint8_t u8;
+
+#define PTR(x) uint32_t
+#define RDRAM_ARG uint8_t *rdram, 
+#define RDRAM_ARG1 uint8_t *rdram
+#define PASS_RDRAM rdram, 
+#define PASS_RDRAM1 rdram
+#define TO_PTR(type, var) ((type*)(&rdram[var & 0x3FFFFFF]))
+#ifdef __cplusplus
+#define NULLPTR (PTR(void))0
+#endif
+
+#ifndef NULL
+#define NULL (PTR(void) 0)
+#endif
+
+#define OS_MESG_NOBLOCK     0
+#define OS_MESG_BLOCK       1
+
+typedef s32 OSPri;
+typedef s32 OSId;
+
+/////////////
+// Structs //
+/////////////
+
+typedef struct UltraThreadContext UltraThreadContext;
+
+typedef enum {
+    RUNNING,
+    PAUSED,
+    PREEMPTED
+} OSThreadState;
+
+typedef struct OSThread_t {
+    PTR(struct OSThread_t) next; // Next thread in the given queue
+    OSPri priority;
+    uint32_t pad1;
+    uint32_t pad2;
+    uint16_t flags; // These two are swapped to reflect rdram byteswapping
+    uint16_t state;
+    OSId id;
+    int32_t pad3;
+    UltraThreadContext* context; // An actual pointer regardless of platform
+    uint32_t sp;
+} OSThread;
+
+typedef u32 OSEvent;
+typedef PTR(void) OSMesg;
+
+// This union holds C++ members along with a padding array. Those members are guarded by an ifdef for C++
+// so that they don't cause compilation errors in C. The padding array reserves the necessary space to
+// hold the atomic members in C and a static assert is used to ensure that the union is large enough.
+// typedef union UltraQueueContext {
+//     u64 pad[1];
+// #ifdef __cplusplus
+//     struct {
+//     } atomics;
+//     // Construct pad instead of the atomics, which get constructed in-place in osCreateMesgQueue
+//     UltraQueueContext() : pad{} {}
+// #endif
+// } UltraQueueContext;
+
+// #ifdef __cplusplus
+// static_assert(sizeof(UltraQueueContext::pad) == sizeof(UltraQueueContext),
+//     "UltraQueueContext does not have enough padding to hold C++ members!");
+// #endif
+
+typedef struct OSMesgQueue {
+    PTR(OSThread) blocked_on_recv; /* Linked list of threads blocked on receiving from this queue */
+    PTR(OSThread) blocked_on_send; /* Linked list of threads blocked on sending to this queue */ 
+    s32 validCount;            /* Number of messages in the queue */
+    s32 first;                 /* Index of the first message in the ring buffer */
+    s32 msgCount;              /* Size of message buffer */
+    PTR(OSMesg) msg;               /* Pointer to circular buffer to store messages */
+} OSMesgQueue;
+
+///////////////
+// Functions //
+///////////////
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+void osInitialize(void);
+
+typedef void (thread_func_t)(PTR(void));
+
+void osCreateThread(RDRAM_ARG PTR(OSThread) t, OSId id, PTR(thread_func_t) entry, PTR(void) arg, PTR(void) sp, OSPri p);
+void osStartThread(RDRAM_ARG PTR(OSThread) t);
+void osSetThreadPri(RDRAM_ARG PTR(OSThread) t, OSPri pri);
+
+s32 MQ_GET_COUNT(RDRAM_ARG PTR(OSMesgQueue));
+s32 MQ_IS_EMPTY(RDRAM_ARG PTR(OSMesgQueue));
+s32 MQ_IS_FULL(RDRAM_ARG PTR(OSMesgQueue));
+
+void osCreateMesgQueue(RDRAM_ARG PTR(OSMesgQueue), PTR(OSMesg), s32);
+s32 osSendMesg(RDRAM_ARG PTR(OSMesgQueue), OSMesg, s32);
+s32 osJamMesg(RDRAM_ARG PTR(OSMesgQueue), OSMesg, s32);
+s32 osRecvMesg(RDRAM_ARG PTR(OSMesgQueue), PTR(OSMesg), s32);
+void osSetEventMesg(RDRAM_ARG OSEvent, PTR(OSMesgQueue), OSMesg);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif