summaryrefslogtreecommitdiff
path: root/src/code
diff options
context:
space:
mode:
Diffstat (limited to 'src/code')
-rw-r--r--src/code/__osMalloc_gc.c (renamed from src/code/__osMalloc.c)48
-rw-r--r--src/code/__osMalloc_n64.c474
-rw-r--r--src/code/code_800FC620.c65
-rw-r--r--src/code/debug_malloc.c3
-rw-r--r--src/code/fault_gc.c10
-rw-r--r--src/code/fault_gc_drawer.c11
-rw-r--r--src/code/fault_n64.c11
-rw-r--r--src/code/game.c1
-rw-r--r--src/code/rand.c13
-rw-r--r--src/code/system_malloc.c13
-rw-r--r--src/code/z_malloc.c3
11 files changed, 578 insertions, 74 deletions
diff --git a/src/code/__osMalloc.c b/src/code/__osMalloc_gc.c
index 598e16a98..45e19532f 100644
--- a/src/code/__osMalloc.c
+++ b/src/code/__osMalloc_gc.c
@@ -1,19 +1,22 @@
#include "global.h"
#include "fault.h"
+#include "osMalloc.h"
#include "terminal.h"
+#if PLATFORM_GC
+
#define FILL_ALLOC_BLOCK_FLAG (1 << 0)
#define FILL_FREE_BLOCK_FLAG (1 << 1)
#define CHECK_FREE_BLOCK_FLAG (1 << 2)
-#define NODE_MAGIC (0x7373)
+#define NODE_MAGIC 0x7373
-#define BLOCK_UNINIT_MAGIC (0xAB)
-#define BLOCK_UNINIT_MAGIC_32 (0xABABABAB)
-#define BLOCK_ALLOC_MAGIC (0xCD)
-#define BLOCK_ALLOC_MAGIC_32 (0xCDCDCDCD)
-#define BLOCK_FREE_MAGIC (0xEF)
-#define BLOCK_FREE_MAGIC_32 (0xEFEFEFEF)
+#define BLOCK_UNINIT_MAGIC 0xAB
+#define BLOCK_UNINIT_MAGIC_32 0xABABABAB
+#define BLOCK_ALLOC_MAGIC 0xCD
+#define BLOCK_ALLOC_MAGIC_32 0xCDCDCDCD
+#define BLOCK_FREE_MAGIC 0xEF
+#define BLOCK_FREE_MAGIC_32 0xEFEFEFEF
#define NODE_IS_VALID(node) (((node) != NULL) && ((node)->magic == NODE_MAGIC))
@@ -24,6 +27,8 @@
#define SET_DEBUG_INFO(node, file, line, arena) ArenaImpl_SetDebugInfo(node, file, line, arena)
+#define FILL_UNINIT_BLOCK(arena, node, size) memset(node, BLOCK_UNINIT_MAGIC, size)
+
#define FILL_ALLOC_BLOCK(arena, alloc, size) \
if ((arena)->flag & FILL_ALLOC_BLOCK_FLAG) \
memset(alloc, BLOCK_ALLOC_MAGIC, size)
@@ -48,6 +53,7 @@
#define NODE_GET_PREV(node) (NODE_IS_VALID((node)->prev) ? (node)->prev : NULL)
#define SET_DEBUG_INFO(node, file, line, arena) (void)0
+#define FILL_UNINIT_BLOCK(arena, node, size) (void)0
#define FILL_ALLOC_BLOCK(arena, alloc, size) (void)0
#define FILL_FREE_BLOCK_HEADER(arena, node) (void)0
#define FILL_FREE_BLOCK_CONTENTS(arena, node) (void)0
@@ -68,6 +74,8 @@ u32 gTotalAllocFailures = 0; // "Arena_failcnt"
OSMesg sArenaLockMsg;
+void __osMallocAddBlock(Arena* arena, void* start, s32 size);
+
#if OOT_DEBUG
u32 __osMalloc_FreeBlockTest_Enable;
@@ -164,7 +172,7 @@ ArenaNode* ArenaImpl_GetLastBlock(Arena* arena) {
return last;
}
-void __osMallocInit(Arena* arena, void* start, u32 size) {
+void __osMallocInit(Arena* arena, void* start, s32 size) {
bzero(arena, sizeof(Arena));
ArenaImpl_LockInit(arena);
__osMallocAddBlock(arena, start, size);
@@ -183,9 +191,7 @@ void __osMallocAddBlock(Arena* arena, void* start, s32 size) {
size2 = (size - diff) & ~0xF;
if (size2 > (s32)sizeof(ArenaNode)) {
-#if OOT_DEBUG
- memset(firstNode, BLOCK_UNINIT_MAGIC, size2);
-#endif
+ FILL_UNINIT_BLOCK(arena, firstNode, size2);
firstNode->next = NULL;
firstNode->prev = NULL;
firstNode->size = size2 - sizeof(ArenaNode);
@@ -230,7 +236,7 @@ void __osMallocCleanup(Arena* arena) {
bzero(arena, sizeof(*arena));
}
-u8 __osMallocIsInitialized(Arena* arena) {
+s32 __osMallocIsInitialized(Arena* arena) {
return arena->isInit;
}
@@ -267,9 +273,9 @@ void* __osMalloc_NoLockDebug(Arena* arena, u32 size, const char* file, int line)
void* alloc = NULL;
ArenaNode* next;
- iter = arena->head;
size = ALIGN16(size);
blockSize = ALIGN16(size) + sizeof(ArenaNode);
+ iter = arena->head;
while (iter != NULL) {
if (iter->isFree && iter->size >= size) {
@@ -357,6 +363,7 @@ void* __osMallocRDebug(Arena* arena, u32 size, const char* file, int line) {
iter = NODE_GET_PREV(iter);
}
+
ArenaImpl_Unlock(arena);
return allocR;
@@ -375,9 +382,9 @@ void* __osMalloc_NoLock(Arena* arena, u32 size) {
iter = arena->head;
while (iter != NULL) {
-
if (iter->isFree && iter->size >= size) {
CHECK_FREE_BLOCK(arena, iter);
+
if (blockSize < iter->size) {
newNode = (ArenaNode*)((u32)iter + blockSize);
newNode->next = NODE_GET_NEXT(iter);
@@ -398,6 +405,7 @@ void* __osMalloc_NoLock(Arena* arena, u32 size) {
SET_DEBUG_INFO(iter, NULL, 0, arena);
alloc = (void*)((u32)iter + sizeof(ArenaNode));
FILL_ALLOC_BLOCK(arena, alloc, size);
+
break;
}
@@ -480,7 +488,7 @@ void __osFree_NoLock(Arena* arena, void* ptr) {
}
node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
- if (node == NULL || node->magic != NODE_MAGIC) {
+ if (!NODE_IS_VALID(node)) {
PRINTF(VT_COL(RED, WHITE) T("__osFree:不正解放(%08x)\n", "__osFree: Unauthorized release (%08x)\n") VT_RST,
ptr);
return;
@@ -546,7 +554,7 @@ void __osFree_NoLockDebug(Arena* arena, void* ptr, const char* file, int line) {
}
node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
- if (node == NULL || node->magic != NODE_MAGIC) {
+ if (!NODE_IS_VALID(node)) {
PRINTF(VT_COL(RED, WHITE)
T("__osFree:不正解放(%08x) [%s:%d ]\n", "__osFree: Unauthorized release (%08x) [%s:%d ]\n") VT_RST,
ptr, file, line);
@@ -573,7 +581,6 @@ void __osFree_NoLockDebug(Arena* arena, void* ptr, const char* file, int line) {
FILL_FREE_BLOCK_CONTENTS(arena, node);
- newNext = node->next;
if ((u32)next == (u32)node + sizeof(ArenaNode) + node->size && next->isFree) {
newNext = NODE_GET_NEXT(next);
if (newNext != NULL) {
@@ -848,7 +855,7 @@ void ArenaImpl_FaultClient(Arena* arena) {
Fault_Printf("Largest Free Block Size %08x\n", maxFree);
}
-u32 __osCheckArena(Arena* arena) {
+s32 __osCheckArena(Arena* arena) {
ArenaNode* iter;
u32 error = 0;
@@ -858,7 +865,8 @@ u32 __osCheckArena(Arena* arena) {
arena);
iter = arena->head;
while (iter != NULL) {
- if (iter && iter->magic == NODE_MAGIC) {
+ //! @bug: Probably intended to be `!NODE_IS_VALID(iter)`
+ if (NODE_IS_VALID(iter)) {
#if OOT_DEBUG
osSyncPrintf(VT_COL(RED, WHITE) T("おおっと！！ (%08x %08x)\n", "Oops!! (%08x %08x)\n") VT_RST, iter,
iter->magic);
@@ -883,3 +891,5 @@ u8 ArenaImpl_GetAllocFailures(Arena* arena) {
return arena->allocFailures;
}
#endif
+
+#endif
diff --git a/src/code/__osMalloc_n64.c b/src/code/__osMalloc_n64.c
new file mode 100644
index 000000000..bd9c358af
--- /dev/null
+++ b/src/code/__osMalloc_n64.c
@@ -0,0 +1,474 @@
+#include "global.h"
+#include "fault.h"
+#include "osMalloc.h"
+
+#if PLATFORM_N64
+
+#define NODE_MAGIC 0x7373
+
+#define NODE_IS_VALID(node) ((node)->magic == NODE_MAGIC)
+
+#define NODE_GET_NEXT(node) ((node)->next)
+#define NODE_GET_PREV(node) ((node)->prev)
+
+#define SET_DEBUG_INFO(node, f, l, a) \
+ { \
+ (node)->filename = (f); \
+ (node)->line = (l); \
+ (node)->threadId = osGetThreadId(NULL); \
+ (node)->arena = (a); \
+ (node)->time = osGetTime(); \
+ } \
+ (void)0
+
+#define FILL_ALLOC_BLOCK(arena, alloc, size) (void)0
+#define FILL_FREE_BLOCK_HEADER(arena, node) (void)0
+#define FILL_FREE_BLOCK_CONTENTS(arena, node) (void)0
+#define CHECK_FREE_BLOCK(arena, node) (void)0
+
+// Number of allocation failures across all arenas.
+u32 gTotalAllocFailures = 0; // "Arena_failcnt"
+
+#define CHECK_ALLOC_FAILURE(arena, ptr) \
+ do { \
+ if ((ptr) == NULL) { \
+ gTotalAllocFailures++; \
+ (arena)->allocFailures++; \
+ } \
+ } while (0)
+
+void __osMallocInit(Arena* arena, void* start, s32 size) {
+ ArenaNode* firstNode = (ArenaNode*)ALIGN16((u32)start);
+
+ size -= (u8*)firstNode - (u8*)start;
+ size &= ~0xF;
+
+ firstNode->next = NULL;
+ firstNode->prev = NULL;
+ firstNode->size = size - sizeof(ArenaNode);
+ firstNode->isFree = true;
+ firstNode->magic = NODE_MAGIC;
+
+ arena->head = firstNode;
+ arena->start = start;
+ arena->size = size;
+}
+
+void __osMallocCleanup(Arena* arena) {
+ bzero(arena, sizeof(*arena));
+}
+
+s32 __osMallocIsInitialized(Arena* arena) {
+ return arena->start != NULL;
+}
+
+void* __osMallocDebug(Arena* arena, u32 size, const char* file, int line) {
+ ArenaNode* iter;
+ u32 blockSize;
+ ArenaNode* newNode;
+ void* alloc = NULL;
+ ArenaNode* next;
+
+ size = ALIGN16(size);
+ blockSize = ALIGN16(size) + sizeof(ArenaNode);
+ iter = arena->head;
+
+ while (iter != NULL) {
+ if (iter->isFree && iter->size >= size) {
+ CHECK_FREE_BLOCK(arena, iter);
+
+ if (blockSize < iter->size) {
+ newNode = (ArenaNode*)((u32)iter + blockSize);
+ newNode->next = NODE_GET_NEXT(iter);
+ newNode->prev = iter;
+ newNode->size = iter->size - blockSize;
+ newNode->isFree = true;
+ newNode->magic = NODE_MAGIC;
+
+ iter->next = newNode;
+ iter->size = size;
+ next = NODE_GET_NEXT(newNode);
+ if (next) {
+ next->prev = newNode;
+ }
+ }
+
+ iter->isFree = false;
+ SET_DEBUG_INFO(iter, file, line, arena);
+ alloc = (void*)((u32)iter + sizeof(ArenaNode));
+ FILL_ALLOC_BLOCK(arena, alloc, size);
+
+ break;
+ }
+
+ iter = NODE_GET_NEXT(iter);
+ }
+
+ CHECK_ALLOC_FAILURE(arena, alloc);
+
+ return alloc;
+}
+
+void* __osMallocRDebug(Arena* arena, u32 size, const char* file, int line) {
+ ArenaNode* iter;
+ ArenaNode* newNode;
+ u32 blockSize;
+ u32 nodeSize;
+ ArenaNode* next;
+ void* allocR = NULL;
+ ArenaNode* next2;
+
+ size = ALIGN16(size);
+
+ iter = arena->head;
+ next2 = NODE_GET_NEXT(iter);
+ while (next2 != NULL) {
+ iter = next2;
+ next2 = NODE_GET_NEXT(next2);
+ }
+
+ while (iter != NULL) {
+ if (iter->isFree && iter->size >= size) {
+ CHECK_FREE_BLOCK(arena, iter);
+
+ blockSize = ALIGN16(size) + sizeof(ArenaNode);
+ nodeSize = iter->size;
+ if (blockSize < nodeSize) {
+ newNode = (ArenaNode*)((u32)iter + (iter->size - size));
+ newNode->next = NODE_GET_NEXT(iter);
+ newNode->prev = iter;
+ newNode->size = size;
+ newNode->magic = NODE_MAGIC;
+
+ iter->next = newNode;
+ iter->size -= blockSize;
+ next = NODE_GET_NEXT(newNode);
+ if (next) {
+ next->prev = newNode;
+ }
+ iter = newNode;
+ }
+
+ iter->isFree = false;
+ SET_DEBUG_INFO(iter, file, line, arena);
+ allocR = (void*)((u32)iter + sizeof(ArenaNode));
+ FILL_ALLOC_BLOCK(arena, allocR, size);
+
+ break;
+ }
+
+ iter = NODE_GET_PREV(iter);
+ }
+
+ CHECK_ALLOC_FAILURE(arena, allocR);
+
+ return allocR;
+}
+
+void* __osMalloc(Arena* arena, u32 size) {
+ ArenaNode* iter;
+ u32 blockSize;
+ ArenaNode* newNode;
+ void* alloc = NULL;
+ ArenaNode* next;
+
+ size = ALIGN16(size);
+ blockSize = ALIGN16(size) + sizeof(ArenaNode);
+ iter = arena->head;
+
+ while (iter != NULL) {
+ if (iter->isFree && iter->size >= size) {
+ CHECK_FREE_BLOCK(arena, iter);
+
+ if (blockSize < iter->size) {
+ newNode = (ArenaNode*)((u32)iter + blockSize);
+ newNode->next = NODE_GET_NEXT(iter);
+ newNode->prev = iter;
+ newNode->size = iter->size - blockSize;
+ newNode->isFree = true;
+ newNode->magic = NODE_MAGIC;
+
+ iter->next = newNode;
+ iter->size = size;
+ next = NODE_GET_NEXT(newNode);
+ if (next) {
+ next->prev = newNode;
+ }
+ }
+
+ iter->isFree = false;
+ SET_DEBUG_INFO(iter, NULL, 0, arena);
+ alloc = (void*)((u32)iter + sizeof(ArenaNode));
+ FILL_ALLOC_BLOCK(arena, alloc, size);
+
+ break;
+ }
+
+ iter = NODE_GET_NEXT(iter);
+ }
+
+ CHECK_ALLOC_FAILURE(arena, alloc);
+
+ return alloc;
+}
+
+void* __osMallocR(Arena* arena, u32 size) {
+ ArenaNode* iter;
+ ArenaNode* newNode;
+ u32 blockSize;
+ u32 nodeSize;
+ ArenaNode* next;
+ void* allocR = NULL;
+ ArenaNode* next2;
+
+ size = ALIGN16(size);
+
+ iter = arena->head;
+ next2 = NODE_GET_NEXT(iter);
+ while (next2 != NULL) {
+ iter = next2;
+ next2 = NODE_GET_NEXT(next2);
+ }
+
+ while (iter != NULL) {
+ if (iter->isFree && iter->size >= size) {
+ CHECK_FREE_BLOCK(arena, iter);
+
+ blockSize = ALIGN16(size) + sizeof(ArenaNode);
+ nodeSize = iter->size;
+ if (blockSize < nodeSize) {
+ newNode = (ArenaNode*)((u32)iter + (iter->size - size));
+ newNode->next = NODE_GET_NEXT(iter);
+ newNode->prev = iter;
+ newNode->size = size;
+ newNode->magic = NODE_MAGIC;
+
+ iter->next = newNode;
+ iter->size -= blockSize;
+ next = NODE_GET_NEXT(newNode);
+ if (next) {
+ next->prev = newNode;
+ }
+ iter = newNode;
+ }
+
+ iter->isFree = false;
+ SET_DEBUG_INFO(iter, NULL, 0, arena);
+ allocR = (void*)((u32)iter + sizeof(ArenaNode));
+ FILL_ALLOC_BLOCK(arena, allocR, size);
+
+ break;
+ }
+ iter = NODE_GET_PREV(iter);
+ }
+
+ CHECK_ALLOC_FAILURE(arena, allocR);
+
+ return allocR;
+}
+
+void __osFree(Arena* arena, void* ptr) {
+ ArenaNode* node;
+ ArenaNode* next;
+ ArenaNode* prev;
+
+ if (ptr == NULL) {
+ return;
+ }
+
+ node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
+ if (!NODE_IS_VALID(node)) {
+ (void)T("__osFree:不正解放(%08x)\n", "__osFree: Unauthorized release (%08x)\n");
+ osSetIntMask(OS_IM_ALL);
+ return;
+ }
+ if (node->isFree) {
+ (void)T("__osFree:二重解放(%08x)\n", "__osFree: Double release (%08x)\n");
+ osSetIntMask(OS_IM_ALL);
+ return;
+ }
+ if (arena != node->arena && arena != NULL) {
+ (void)T("__osFree:arena(%08x)が__osMallocのarena(%08x)と一致しない\n",
+ "__osFree:arena(%08x) and __osMalloc:arena(%08x) do not match\n");
+ }
+
+ node->isFree = true;
+ SET_DEBUG_INFO(node, NULL, 0, arena);
+
+ if (node->next != NULL) {
+ next = node->next;
+ if (next->isFree) {
+ if (next->next != NULL) {
+ next->next->prev = node;
+ }
+
+ node->size += next->size + sizeof(ArenaNode);
+ node->next = next->next;
+ }
+ }
+
+ if (node->prev != NULL) {
+ prev = node->prev;
+ if (prev->isFree) {
+ prev->size += node->size + sizeof(ArenaNode);
+ prev->next = NODE_GET_NEXT(node);
+
+ if (node->next != NULL) {
+ node->next->prev = prev;
+ }
+ }
+ }
+}
+
+void __osFreeDebug(Arena* arena, void* ptr, const char* file, int line) {
+ ArenaNode* node;
+ ArenaNode* next;
+ ArenaNode* prev;
+
+ if (ptr == NULL) {
+ return;
+ }
+
+ node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
+ if (!NODE_IS_VALID(node)) {
+ (void)T("__osFree:不正解放(%08x)\n", "__osFree: Unauthorized release (%08x)\n");
+ osSetIntMask(OS_IM_ALL);
+ return;
+ }
+ if (node->isFree) {
+ (void)T("__osFree:二重解放(%08x)\n", "__osFree: Double release (%08x)\n");
+ osSetIntMask(OS_IM_ALL);
+ return;
+ }
+ if (arena != node->arena && arena != NULL) {
+ (void)T("__osFree:arena(%08x)が__osMallocのarena(%08x)と一致しない\n",
+ "__osFree:arena(%08x) and __osMalloc:arena(%08x) do not match\n");
+ }
+
+ node->isFree = true;
+ SET_DEBUG_INFO(node, file, line, arena);
+
+ if (node->next != NULL) {
+ next = node->next;
+ if (next->isFree) {
+ if (next->next != NULL) {
+ next->next->prev = node;
+ }
+
+ node->size += next->size + sizeof(ArenaNode);
+ node->next = next->next;
+ }
+ }
+
+ if (node->prev != NULL) {
+ prev = node->prev;
+ if (prev->isFree) {
+ prev->size += node->size + sizeof(ArenaNode);
+ prev->next = NODE_GET_NEXT(node);
+
+ if (node->next != NULL) {
+ node->next->prev = prev;
+ }
+ }
+ }
+}
+
+void* __osRealloc(Arena* arena, void* ptr, u32 newSize) {
+ ArenaNode* node;
+ void* newAlloc;
+ ArenaNode* next;
+ ArenaNode* newNext;
+ u32 sizeDiff;
+
+ (void)"__osRealloc(%08x, %d)\n";
+ osSetIntMask(OS_IM_ALL);
+
+ if (ptr == NULL) {
+ ptr = __osMalloc(arena, newSize);
+ } else if (newSize == 0) {
+ __osFree(arena, ptr);
+ ptr = NULL;
+ } else {
+ newSize = ALIGN16(newSize);
+ node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
+ if (newSize == node->size) {
+ // Do nothing
+ } else if (node->size < newSize) {
+ next = NODE_GET_NEXT(node);
+ sizeDiff = newSize - node->size;
+ if (next != NULL && next->isFree && next->size >= sizeDiff) {
+ next->size -= sizeDiff;
+ newNext = (ArenaNode*)((u32)next + sizeDiff);
+ if (NODE_GET_NEXT(next) != NULL) {
+ NODE_GET_NEXT(next)->prev = newNext;
+ }
+ node->next = newNext;
+ node->size = newSize;
+ memmove(node->next, next, sizeof(ArenaNode));
+ } else {
+ newAlloc = __osMalloc(arena, newSize);
+ if (newAlloc != NULL) {
+ memcpy(ptr, newAlloc, node->size);
+ __osFree(arena, ptr);
+ }
+ ptr = newAlloc;
+ }
+ } else if (newSize < node->size) {
+ (void)T("メモリブロックの縮小機能はまだインプリメントしていません\n",
+ "Memory block shrinking functionality is not yet implemented\n");
+ }
+ }
+
+ CHECK_ALLOC_FAILURE(arena, ptr);
+
+ return ptr;
+}
+
+void* __osReallocDebug(Arena* arena, void* ptr, u32 newSize, const char* file, int line) {
+ return __osRealloc(arena, ptr, newSize);
+}
+
+void ArenaImpl_GetSizes(Arena* arena, u32* outMaxFree, u32* outFree, u32* outAlloc) {
+ ArenaNode* iter;
+
+ *outMaxFree = 0;
+ *outFree = 0;
+ *outAlloc = 0;
+
+ iter = arena->head;
+ while (iter != NULL) {
+ if (iter->isFree) {
+ *outFree += iter->size;
+ if (*outMaxFree < iter->size) {
+ *outMaxFree = iter->size;
+ }
+ } else {
+ *outAlloc += iter->size;
+ }
+
+ iter = NODE_GET_NEXT(iter);
+ }
+}
+
+s32 __osCheckArena(Arena* arena) {
+ ArenaNode* iter;
+
+ (void)T("アリーナの内容をチェックしています．．． (%08x)\n", "Checking the arena contents... (%08x)\n");
+ iter = arena->head;
+ while (iter != NULL) {
+ if (!NODE_IS_VALID(iter)) {
+ (void)T("おおっと！！ (%08x %08x)\n", "Oops!! (%08x %08x)\n");
+ return 1;
+ }
+ iter = NODE_GET_NEXT(iter);
+ }
+
+ (void)T("アリーナはまだ、いけそうです\n", "The arena is still going well\n");
+ return 0;
+}
+
+u8 ArenaImpl_GetAllocFailures(Arena* arena) {
+ return arena->allocFailures;
+}
+
+#endif
diff --git a/src/code/code_800FC620.c b/src/code/code_800FC620.c
index eafbe5080..4d7b7b4ef 100644
--- a/src/code/code_800FC620.c
+++ b/src/code/code_800FC620.c
@@ -1,4 +1,5 @@
#include "global.h"
+#include "osMalloc.h"
typedef void (*arg3_800FC868)(void*);
typedef void (*arg3_800FC8D8)(void*, u32);
@@ -26,43 +27,64 @@ char D_80134488[0x18] = {
// possibly some kind of new() function
void* func_800FC800(u32 size) {
+ DECLARE_INTERRUPT_MASK
+ void* ptr;
+
+ DISABLE_INTERRUPTS();
+
if (size == 0) {
size = 1;
}
#if OOT_DEBUG
- return __osMallocDebug(&gSystemArena, size, sNew, 0);
+ ptr = __osMallocDebug(&gSystemArena, size, sNew, 0);
#else
- return __osMalloc(&gSystemArena, size);
+ ptr = __osMalloc(&gSystemArena, size);
#endif
+
+ RESTORE_INTERRUPTS();
+ return ptr;
}
// possibly some kind of delete() function
void func_800FC83C(void* ptr) {
+ DECLARE_INTERRUPT_MASK
+
+ DISABLE_INTERRUPTS();
if (ptr != NULL) {
__osFree(&gSystemArena, ptr);
}
+ RESTORE_INTERRUPTS();
}
void func_800FC868(void* blk, u32 nBlk, u32 blkSize, arg3_800FC868 arg3) {
+ DECLARE_INTERRUPT_MASK
u32 pos;
- for (pos = (u32)blk; pos < (u32)blk + (nBlk * blkSize); pos = (u32)pos + (blkSize & ~0)) {
+ DISABLE_INTERRUPTS();
+ for (pos = ((u32)blk & ~0); pos < (u32)blk + (nBlk * blkSize); pos = (u32)pos + (blkSize & ~0)) {
arg3((void*)pos);
}
+ RESTORE_INTERRUPTS();
}
void func_800FC8D8(void* blk, u32 nBlk, s32 blkSize, arg3_800FC8D8 arg3) {
+ DECLARE_INTERRUPT_MASK
u32 pos;
- for (pos = (u32)blk; pos < (u32)blk + (nBlk * blkSize); pos = (u32)pos + (blkSize & ~0)) {
+ DISABLE_INTERRUPTS();
+ for (pos = ((u32)blk & ~0); pos < (u32)blk + (nBlk * blkSize); pos = (u32)pos + (blkSize & ~0)) {
arg3((void*)pos, 2);
}
+ RESTORE_INTERRUPTS();
}
void* func_800FC948(void* blk, u32 nBlk, u32 blkSize, arg3_800FC948 arg3) {
+ DECLARE_INTERRUPT_MASK
u32 pos;
+ DISABLE_INTERRUPTS();
+
if (blk == NULL) {
blk = func_800FC800(nBlk * blkSize);
}
@@ -74,29 +96,35 @@ void* func_800FC948(void* blk, u32 nBlk, u32 blkSize, arg3_800FC948 arg3) {
pos = (u32)pos + (blkSize & ~0);
}
}
+
+ RESTORE_INTERRUPTS();
return blk;
}
void func_800FCA18(void* blk, u32 nBlk, u32 blkSize, arg3_800FCA18 arg3, s32 arg4) {
+ DECLARE_INTERRUPT_MASK
u32 pos;
u32 end;
- if (blk == NULL) {
- return;
- }
- if (arg3 != NULL) {
- end = (u32)blk;
- pos = (u32)end + (nBlk * blkSize);
+ DISABLE_INTERRUPTS();
- while (pos > end) {
- pos -= (s32)(blkSize & ~0);
- arg3((void*)pos, 2);
+ if (blk != NULL) {
+ if (arg3 != NULL) {
+ end = (u32)blk;
+ pos = (u32)end + (nBlk * blkSize);
+
+ while (pos > end) {
+ pos -= (s32)(blkSize & ~0);
+ arg3((void*)pos, 2);
+ }
}
- }
- if (arg4 != 0) {
- func_800FC83C(blk);
+ if (arg4 != 0) {
+ func_800FC83C(blk);
+ }
}
+
+ RESTORE_INTERRUPTS();
}
void func_800FCB34(void) {
@@ -120,6 +148,11 @@ void func_800FCB34(void) {
}
void SystemHeap_Init(void* start, u32 size) {
+#if PLATFORM_N64
+ __osMallocInit(&gSystemArena, start, size);
+#else
SystemArena_Init(start, size);
+#endif
+
func_800FCB34();
}
diff --git a/src/code/debug_malloc.c b/src/code/debug_malloc.c
index 3e31f7845..5be04b23c 100644
--- a/src/code/debug_malloc.c
+++ b/src/code/debug_malloc.c
@@ -1,4 +1,5 @@
#include "global.h"
+#include "osMalloc.h"
#define LOG_SEVERITY_NOLOG 0
#define LOG_SEVERITY_ERROR 2
@@ -125,6 +126,6 @@ void DebugArena_Cleanup(void) {
__osMallocCleanup(&sDebugArena);
}
-u8 DebugArena_IsInitialized(void) {
+s32 DebugArena_IsInitialized(void) {
return __osMallocIsInitialized(&sDebugArena);
}
diff --git a/src/code/fault_gc.c b/src/code/fault_gc.c
index 587f7cb24..0402573ad 100644
--- a/src/code/fault_gc.c
+++ b/src/code/fault_gc.c
@@ -40,15 +40,11 @@
* DPad-Up may be pressed to enable sending fault pages over osSyncPrintf as well as displaying them on-screen.
* DPad-Down disables sending fault pages over osSyncPrintf.
*/
+#if PLATFORM_GC
+
#pragma increment_block_number "gc-eu:240 gc-eu-mq:240 gc-eu-mq-dbg:224 gc-jp:240 gc-jp-ce:240 gc-jp-mq:240 gc-us:240" \
"gc-us-mq:240"
-// Include versions.h first and redefine FAULT_VERSION
-// This allows this file to compile even when versions.h uses FAULT_N64
-#include "versions.h"
-#undef FAULT_VERSION
-#define FAULT_VERSION FAULT_GC
-
#include "global.h"
#include "alloca.h"
#include "fault.h"
@@ -1336,3 +1332,5 @@ NORETURN void Fault_AddHungupAndCrash(const char* file, int line) {
sprintf(msg, "HungUp %s:%d", file, line);
Fault_AddHungupAndCrashImpl(msg, NULL);
}
+
+#endif
diff --git a/src/code/fault_gc_drawer.c b/src/code/fault_gc_drawer.c
index dbdcba7e7..5cf088fca 100644
--- a/src/code/fault_gc_drawer.c
+++ b/src/code/fault_gc_drawer.c
@@ -4,17 +4,12 @@
* Implements routines for drawing text with a fixed font directly to a framebuffer, used in displaying
* the crash screen implemented by fault.c
*/
-
-// Include versions.h first and redefine FAULT_VERSION
-// This allows this file to compile even when versions.h uses FAULT_N64
-#include "versions.h"
-#undef FAULT_VERSION
-#define FAULT_VERSION FAULT_GC
-
#include "global.h"
#include "fault.h"
#include "terminal.h"
+#if PLATFORM_GC
+
typedef struct FaultDrawer {
/* 0x00 */ u16* fb;
/* 0x04 */ u16 w;
@@ -348,3 +343,5 @@ void Fault_InitDrawer(void) {
bcopy(&sFaultDrawerDefault, &sFaultDrawer, sizeof(FaultDrawer));
sFaultDrawer.fb = (u16*)(PHYS_TO_K0(osMemSize) - sizeof(u16[SCREEN_HEIGHT][SCREEN_WIDTH]));
}
+
+#endif
diff --git a/src/code/fault_n64.c b/src/code/fault_n64.c
index da9d7bf6f..5a8dd9d1d 100644
--- a/src/code/fault_n64.c
+++ b/src/code/fault_n64.c
@@ -1,14 +1,11 @@
-// Include versions.h first and redefine FAULT_VERSION
-// This allows this file to compile even when versions.h uses FAULT_GC
-#include "versions.h"
-#undef FAULT_VERSION
-#define FAULT_VERSION FAULT_N64
-
#include "global.h"
#include "fault.h"
+#include "osMalloc.h"
#include "stack.h"
#include "terminal.h"
+#if PLATFORM_N64
+
typedef struct FaultMgr {
OSThread thread;
char unk_1B0[0x400];
@@ -846,3 +843,5 @@ void Fault_AddHungupAndCrash(const char* file, int line) {
sprintf(msg, "HungUp %s:%d", file, line);
Fault_AddHungupAndCrashImpl(msg, NULL);
}
+
+#endif
diff --git a/src/code/game.c b/src/code/game.c
index ffb8bc847..07007f6a7 100644
--- a/src/code/game.c
+++ b/src/code/game.c
@@ -1,5 +1,6 @@
#include "global.h"
#include "fault.h"
+#include "osMalloc.h"
#include "terminal.h"
#if PLATFORM_N64
#include "n64dd.h"
diff --git a/src/code/rand.c b/src/code/rand.c
index ce2beb9e3..917b1ecfc 100644
--- a/src/code/rand.c
+++ b/src/code/rand.c
@@ -42,7 +42,6 @@
* @note Original name: qrand.c
*/
#include "rand.h"
-#include "versions.h"
#define RAND_MULTIPLIER 1664525
#define RAND_INCREMENT 1013904223
@@ -54,7 +53,7 @@
*/
static u32 sRandInt = 1;
-#if RAND_VERSION == RAND_GC
+#if PLATFORM_GC
/**
* Space to store a value to be re-interpreted as a float.
*
@@ -69,7 +68,7 @@ static fu sRandFloat;
* @note Original name: qrand
*/
u32 Rand_Next(void) {
-#if RAND_VERSION == RAND_N64
+#if PLATFORM_N64
u32 next = sRandInt * RAND_MULTIPLIER + RAND_INCREMENT;
sRandInt = next;
@@ -98,7 +97,7 @@ void Rand_Seed(u32 seed) {
* @note Original name: fqrand
*/
f32 Rand_ZeroOne(void) {
-#if RAND_VERSION == RAND_N64
+#if PLATFORM_N64
fu v;
f32 vf;
@@ -115,7 +114,7 @@ f32 Rand_ZeroOne(void) {
#endif
}
-#if RAND_VERSION == RAND_GC
+#if PLATFORM_GC
/**
* Returns a pseudo-random floating-point number between -0.5f and 0.5f by the same manner in which Rand_ZeroOne
* generates its result.
@@ -164,7 +163,7 @@ u32 Rand_Next_Variable(u32* rndNum) {
* @note Original name: fqrand_r
*/
f32 Rand_ZeroOne_Variable(u32* rndNum) {
-#if RAND_VERSION == RAND_N64
+#if PLATFORM_N64
fu v;
f32 vf;
u32 next = Rand_Next_Variable(rndNum);
@@ -180,7 +179,7 @@ f32 Rand_ZeroOne_Variable(u32* rndNum) {
#endif
}
-#if RAND_VERSION == RAND_GC
+#if PLATFORM_GC
/**
* Generates the next pseudo-random floating-point number between -0.5f and 0.5f from the provided rndNum.
*
diff --git a/src/code/system_malloc.c b/src/code/system_malloc.c
index 8385a883c..de6a56b30 100644
--- a/src/code/system_malloc.c
+++ b/src/code/system_malloc.c
@@ -1,4 +1,5 @@
#include "global.h"
+#include "osMalloc.h"
#define LOG_SEVERITY_NOLOG 0
#define LOG_SEVERITY_ERROR 2
@@ -6,16 +7,6 @@
Arena gSystemArena;
-#if PLATFORM_N64
-#define DECLARE_INTERRUPT_MASK OSIntMask __mask;
-#define DISABLE_INTERRUPTS() __mask = osSetIntMask(OS_IM_NONE)
-#define RESTORE_INTERRUPTS() osSetIntMask(__mask)
-#else
-#define DECLARE_INTERRUPT_MASK
-#define DISABLE_INTERRUPTS() (void)0
-#define RESTORE_INTERRUPTS() (void)0
-#endif
-
#if OOT_DEBUG
s32 gSystemArenaLogSeverity = LOG_SEVERITY_NOLOG;
@@ -176,6 +167,6 @@ void SystemArena_Cleanup(void) {
__osMallocCleanup(&gSystemArena);
}
-u8 SystemArena_IsInitialized(void) {
+s32 SystemArena_IsInitialized(void) {
return __osMallocIsInitialized(&gSystemArena);
}
diff --git a/src/code/z_malloc.c b/src/code/z_malloc.c
index 979de62fe..5b1c5637f 100644
--- a/src/code/z_malloc.c
+++ b/src/code/z_malloc.c
@@ -1,4 +1,5 @@
#include "global.h"
+#include "osMalloc.h"
#define LOG_SEVERITY_NOLOG 0
#define LOG_SEVERITY_ERROR 2
@@ -124,6 +125,6 @@ void ZeldaArena_Cleanup(void) {
__osMallocCleanup(&sZeldaArena);
}
-u8 ZeldaArena_IsInitialized(void) {
+s32 ZeldaArena_IsInitialized(void) {
return __osMallocIsInitialized(&sZeldaArena);
}
generated by cgit v1.2.3 (git 2.25.1) at 2026-08-03 18:00:29 +0000