mirror/oot
1
0
Fork 0
mirror of https://github.com/zeldaret/oot.git synced 2025-07-03 22:44:30 +00:00
Code Issues Projects Releases Wiki Activity

[ntsc-1.2] Match __osMalloc.c and code_800FC620.c (new/delete) (#2106)

Browse source 
* Match __osMalloc

* Match src/code/code_800FC620.c (new/delete)

* Wrap versions-specific files in ifdefs to fix compilation

* Fix bss

* Remove {FAULT,RAND,OSMALLOC}_VERSION in favor of PLATFORM_N64

* Fix __osMalloc data splits, add unused strings

* __osMalloc.h -> osMalloc.h

* Fix merge
This commit is contained in:
cadmic 2024-09-04 02:10:14 -07:00 • committed by GitHub
parent af24970d89
commit c6d7cc7697
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
24 changed files with 682 additions and 159 deletions
Download patch file Download diff file Expand all files Collapse all files

48
src/code/__osMalloc.c → src/code/__osMalloc_gc.c
View file

@ -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

474
src/code/__osMalloc_n64.c Normal file
View file

@ -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

65
src/code/code_800FC620.c
View file

@ -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();
}

3
src/code/debug_malloc.c
View file

@ -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);
}

10
src/code/fault_gc.c
View file

@ -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

11
src/code/fault_gc_drawer.c
View file

@ -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

11
src/code/fault_n64.c
View file

@ -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

1
src/code/game.c
View file

@ -1,5 +1,6 @@
#include "global.h"
#include "fault.h"
#include "osMalloc.h"
#include "terminal.h"
#if PLATFORM_N64
#include "n64dd.h"

13
src/code/rand.c
View file

@ -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.
*

13
src/code/system_malloc.c
View file

@ -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);
}

3
src/code/z_malloc.c
View file

@ -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);
}