falso
/
mm
mirror of https://github.com/zeldaret/mm.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge 13288384ca into 0877ce4adf

This commit is contained in:
Anghelo Carvajal 2025-12-15 19:30:19 +09:00 committed by GitHub
parent 0877ce4adf 13288384ca
commit 52601860b0
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
4 changed files with 329 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
include/libc64/os_malloc.h
View File

@ -4,19 +4,32 @@
#include "ultra64.h"
#include "stddef.h"
#include "unk.h"
#include "versions.h"
struct Arena;
typedef struct ArenaNode {
/* 0x0 */ s16 magic; // Should always be 0x7373
/* 0x2 */ s16 isFree;
/* 0x4 */ size_t size;
/* 0x8 */ struct ArenaNode* next;
/* 0xC */ struct ArenaNode* prev;
} ArenaNode; // size = 0x10
#if MM_VERSION <= N64_JP_1_1
/* 0x10 */ const char* filename;
/* 0x14 */ int line;
/* 0x18 */ OSId threadId;
/* 0x1C */ struct Arena *arena;
/* 0x20 */ OSTime time;
/* 0x28 */ UNK_TYPE1 unk_28[0x8];
#endif
} ArenaNode; // size = 0x10 N64 US, size = 0x30 N64 JP 1.1
typedef struct Arena {
/* 0x00 */ ArenaNode* head;
/* 0x04 */ void* start;
/* 0x08 */ OSMesgQueue lock;
/* 0x20 */ u8 unk20;
/* 0x20 */ u8 allocFailures;
/* 0x21 */ u8 isInit;
/* 0x22 */ u8 flag;
} Arena; // size = 0x24
@ -31,4 +44,14 @@ void* __osRealloc(Arena* arena, void* ptr, size_t newSize);
void __osGetSizes(Arena* arena, size_t* outMaxFree, size_t* outFree, size_t* outAlloc);
s32 __osCheckArena(Arena* arena);
#if MM_VERSION <= N64_JP_1_1
void *__osMallocDebug(Arena *arena, size_t size, const char* file, int line);
void *__osMallocRDebug(Arena *arena, size_t size, const char* file, int line);
void __osFreeDebug(Arena* arena, void* ptr, const char* file, int line);
void *__osReallocDebug(Arena* arena, void* ptr, size_t newSize, const char* file, int line);
u8 ArenaImpl_GetAllocFailures(Arena* arena);
extern s32 gTotalAllocFailures;
#endif
#endif

333
src/boot/libc64/__osMalloc.c
View File

@ -19,6 +19,38 @@
#define BLOCK_FREE_MAGIC (0xEF)
#define BLOCK_FREE_MAGIC_32 (0xEFEFEFEF)
#define NODE_IS_VALID(node) ((node)->magic == NODE_MAGIC)
#if MM_VERSION >= N64_US
#define SET_DEBUG_INFO(node, f, l, a) ((void)0)
#define CHECK_CORRECT_ARENA(node, arena) (true)
#define CHECK_ALLOC_FAILURE(arena, ptr) (void)0
#else
#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 CHECK_CORRECT_ARENA(node, arena) ((node)->arena == (arena))
s32 gTotalAllocFailures = 0; // "Arena_failcnt"
#define CHECK_ALLOC_FAILURE(arena, ptr) \
do { \
if ((ptr) == NULL) { \
gTotalAllocFailures++; \
(arena)->allocFailures++; \
} \
} while (0)
#endif
OSMesg sArenaLockMsg[1];
void __osMallocAddHeap(Arena* arena, void* heap, size_t size);
@ -127,6 +159,107 @@ u8 __osMallocIsInitialized(Arena* arena) {
return arena->isInit;
}
#if MM_VERSION < N64_US
void* __osMallocDebug(Arena* arena, size_t size, const char* file, int line) {
ArenaNode* iter;
ArenaNode* newNode;
void* alloc = NULL;
ArenaImpl_Lock(arena);
size = ALIGN16(size);
for (iter = arena->head; iter != NULL; iter = iter->next) {
if (iter->isFree && (iter->size >= size)) {
size_t blockSize = ALIGN16(size) + sizeof(ArenaNode);
if (blockSize < iter->size) {
ArenaNode* next;
newNode = (ArenaNode*)((uintptr_t)iter + blockSize);
newNode->next = iter->next;
newNode->prev = iter;
newNode->size = iter->size - blockSize;
newNode->isFree = true;
newNode->magic = NODE_MAGIC;
iter->next = newNode;
iter->size = size;
next = newNode->next;
if (next != NULL) {
next->prev = newNode;
}
}
iter->isFree = false;
SET_DEBUG_INFO(iter, file, line, arena);
alloc = (void*)((uintptr_t)iter + sizeof(ArenaNode));
break;
}
}
CHECK_ALLOC_FAILURE(arena, alloc);
ArenaImpl_Unlock(arena);
return alloc;
}
#endif
#if MM_VERSION < N64_US
void* __osMallocRDebug(Arena* arena, size_t size, const char* file, int line) {
ArenaNode* iter;
ArenaNode* newNode;
size_t blockSize;
void* alloc = NULL;
size = ALIGN16(size);
ArenaImpl_Lock(arena);
for (iter = ArenaImpl_GetLastBlock(arena); iter != NULL; iter = iter->prev) {
if (iter->isFree && (iter->size >= size)) {
blockSize = ALIGN16(size) + sizeof(ArenaNode);
if (blockSize < iter->size) {
ArenaNode* next;
newNode = (ArenaNode*)(((uintptr_t)iter + iter->size) - size);
newNode->next = iter->next;
newNode->prev = iter;
newNode->size = size;
newNode->magic = NODE_MAGIC;
iter->next = newNode;
iter->size -= blockSize;
next = newNode->next;
if (next != NULL) {
next->prev = newNode;
}
iter = newNode;
}
iter->isFree = false;
SET_DEBUG_INFO(iter, file, line, arena);
alloc = (void*)((uintptr_t)iter + sizeof(ArenaNode));
break;
}
}
CHECK_ALLOC_FAILURE(arena, alloc);
ArenaImpl_Unlock(arena);
return alloc;
}
#endif
/**
* Allocates at least \p size bytes of memory using the given \p arena.
* The block of memory will be allocated at the start of the first sufficiently large free block.
@ -155,7 +288,7 @@ void* __osMalloc(Arena* arena, size_t size) {
// Iterate over the arena looking for a big enough space of memory.
while (iter != NULL) {
if (iter->isFree && iter->size >= size) {
if (iter->isFree && (iter->size >= size)) {
size_t blockSize = ALIGN16(size) + sizeof(ArenaNode);
// If the block is larger than the requested size, then split it and just use the required size of the
@ -180,6 +313,9 @@ void* __osMalloc(Arena* arena, size_t size) {
}
iter->isFree = false;
SET_DEBUG_INFO(iter, NULL, 0, arena);
alloc = (void*)((uintptr_t)iter + sizeof(ArenaNode));
break;
}
@ -187,6 +323,8 @@ void* __osMalloc(Arena* arena, size_t size) {
iter = iter->next;
}
CHECK_ALLOC_FAILURE(arena, alloc);
ArenaImpl_Unlock(arena);
return alloc;
@ -245,12 +383,17 @@ void* __osMallocR(Arena* arena, size_t size) {
}
iter->isFree = false;
SET_DEBUG_INFO(iter, NULL, 0, arena);
alloc = (void*)((uintptr_t)iter + sizeof(ArenaNode));
break;
}
iter = iter->prev;
}
CHECK_ALLOC_FAILURE(arena, alloc);
ArenaImpl_Unlock(arena);
return alloc;
@ -275,43 +418,141 @@ void __osFree(Arena* arena, void* ptr) {
ArenaImpl_Lock(arena);
node = (ArenaNode*)((uintptr_t)ptr - sizeof(ArenaNode));
if ((ptr != NULL) && (node->magic == NODE_MAGIC) && !node->isFree) {
next = node->next;
prev = node->prev;
node->isFree = true;
// Checks if the next node is contiguous to the current node and if it isn't currently allocated. Then merge the
// two nodes into one.
if ((uintptr_t)next == (uintptr_t)node + sizeof(ArenaNode) + node->size && next->isFree) {
ArenaNode* newNext = next->next;
if (newNext != NULL) {
newNext->prev = node;
}
node->size += next->size + sizeof(ArenaNode);
node->next = newNext;
next = newNext;
}
// Checks if the previous node is contiguous to the current node and if it isn't currently allocated. Then merge
// the two nodes into one.
if ((prev != NULL) && prev->isFree && ((uintptr_t)node == (uintptr_t)prev + sizeof(ArenaNode) + prev->size)) {
if (next != NULL) {
next->prev = prev;
}
prev->next = next;
prev->size += node->size + sizeof(ArenaNode);
}
if (ptr == NULL) {
goto cleanup;
}
node = (ArenaNode*)((uintptr_t)ptr - sizeof(ArenaNode));
if (!NODE_IS_VALID(node)) {
#if MM_VERSION < N64_US
// __osFree:Unauthorized release(%08x)\n
(void)"__osFree:不正解放(%08x)\n";
#endif
goto cleanup;
}
if (node->isFree) {
#if MM_VERSION < N64_US
// __osFree:Double release(%08x)\n
(void)"__osFree:二重解放(%08x)\n";
#endif
goto cleanup;
}
if (!CHECK_CORRECT_ARENA(node, arena)) {
#if MM_VERSION < N64_US
// __osFree:arena(%08x) and __osMallocのarena(%08x) do not match\n
(void)"__osFree:arena(%08x)が__osMallocのarena(%08x)と一致しない\n";
#endif
goto cleanup;
}
next = node->next;
prev = node->prev;
node->isFree = true;
SET_DEBUG_INFO(node, NULL, 0, arena);
// Checks if the next node is contiguous to the current node and if it isn't currently allocated. Then merge the
// two nodes into one.
if (((uintptr_t)next == (uintptr_t)node + sizeof(ArenaNode) + node->size) && next->isFree) {
ArenaNode* newNext = next->next;
if (newNext != NULL) {
newNext->prev = node;
}
node->size += next->size + sizeof(ArenaNode);
node->next = newNext;
next = newNext;
}
// Checks if the previous node is contiguous to the current node and if it isn't currently allocated. Then merge
// the two nodes into one.
if ((prev != NULL) && prev->isFree && ((uintptr_t)node == (uintptr_t)prev + sizeof(ArenaNode) + prev->size)) {
if (next != NULL) {
next->prev = prev;
}
prev->next = next;
prev->size += node->size + sizeof(ArenaNode);
}
cleanup:
ArenaImpl_Unlock(arena);
}
#if MM_VERSION < N64_US
void __osFreeDebug(Arena* arena, void* ptr, const char* file, int line) {
ArenaNode* node;
ArenaNode* next;
ArenaNode* prev;
ArenaImpl_Lock(arena);
if (ptr == NULL) {
goto cleanup;
}
node = (ArenaNode*)((uintptr_t)ptr - sizeof(ArenaNode));
if (!NODE_IS_VALID(node)) {
// __osFree:Unauthorized release(%08x)\n
(void)"__osFree:不正解放(%08x)\n";
goto cleanup;
}
if (node->isFree) {
// __osFree:Double release(%08x)\n
(void)"__osFree:二重解放(%08x)\n";
goto cleanup;
}
if (!CHECK_CORRECT_ARENA(node, arena)) {
// __osFree:arena(%08x) and __osMallocのarena(%08x) do not match\n
(void)"__osFree:arena(%08x)が__osMallocのarena(%08x)と一致しない\n";
goto cleanup;
}
next = node->next;
prev = node->prev;
node->isFree = true;
SET_DEBUG_INFO(node, file, line, arena);
// Checks if the next node is contiguous to the current node and if it isn't currently allocated. Then merge the
// two nodes into one.
if (((uintptr_t)next == (uintptr_t)node + sizeof(ArenaNode) + node->size) && next->isFree) {
ArenaNode* newNext = next->next;
if (newNext != NULL) {
newNext->prev = node;
}
node->size += next->size + sizeof(ArenaNode);
node->next = newNext;
next = newNext;
}
// Checks if the previous node is contiguous to the current node and if it isn't currently allocated. Then merge
// the two nodes into one.
if ((prev != NULL) && prev->isFree && ((uintptr_t)node == (uintptr_t)prev + sizeof(ArenaNode) + prev->size)) {
if (next != NULL) {
next->prev = prev;
}
prev->next = next;
prev->size += node->size + sizeof(ArenaNode);
}
cleanup:
ArenaImpl_Unlock(arena);
}
#endif
/**
* Reallocates the pointer \p ptr.
* \p ptr must be either a pointer previously allocated by `__osMalloc`, `__osMallocR` or `__osRealloc` and
@ -354,18 +595,19 @@ void* __osRealloc(Arena* arena, void* ptr, size_t newSize) {
newSize = ALIGN16(newSize);
// Only reallocate the memory if the new size isn't smaller than the actual node size
if ((newSize != node->size) && (node->size < newSize)) {
if (newSize == node->size) {
// Do nothing
} else if (node->size < newSize) {
ArenaNode* next = node->next;
diff = newSize - node->size;
// Checks if the next node is contiguous to the current allocated node and it has enough space to fit the
// new requested size
if (((uintptr_t)next == (uintptr_t)node + node->size + sizeof(ArenaNode)) && (next->isFree) &&
if (((uintptr_t)next == (uintptr_t)node + node->size + sizeof(ArenaNode)) && next->isFree &&
(next->size >= diff)) {
ArenaNode* next2 = next->next;
next->size = (next->size - diff);
next->size = next->size - diff;
if (next2 != NULL) {
// Update the previous element of the linked list
next2->prev = (void*)((uintptr_t)next + diff);
@ -384,14 +626,23 @@ void* __osRealloc(Arena* arena, void* ptr, size_t newSize) {
}
ptr = newPtr;
}
} else if (newSize < node->size) {
}
}
CHECK_ALLOC_FAILURE(arena, ptr);
ArenaImpl_Unlock(arena);
return ptr;
}
#if MM_VERSION < N64_US
void* __osReallocDebug(Arena* arena, void* ptr, size_t newSize, const char* file, int line) {
return __osRealloc(arena, ptr, newSize);
}
#endif
/**
* Gets the size of the largest free block, the total free space and the total allocated space.
*
@ -442,7 +693,7 @@ s32 __osCheckArena(Arena* arena) {
(void)"アリーナの内容をチェックしています．．． (%08x)\n";
for (iter = arena->head; iter != NULL; iter = iter->next) {
if (iter->magic != NODE_MAGIC) {
if (!NODE_IS_VALID(iter)) {
// "Oops!!"
(void)"おおっと！！ (%08x %08x)\n";
@ -458,3 +709,9 @@ s32 __osCheckArena(Arena* arena) {
return err;
}
#if MM_VERSION < N64_US
u8 ArenaImpl_GetAllocFailures(Arena* arena) {
return arena->allocFailures;
}
#endif

8
src/code/gamealloc.c
View File

@ -5,7 +5,15 @@
void GameAlloc_Log(GameAlloc* this) {
GameAllocEntry* iter = this->base.next;
#if MM_VERSION <= N64_JP_1_1
(void)"this = %08x\n";
#endif
while (iter != &this->base) {
#if MM_VERSION <= N64_JP_1_1
(void)"ptr = %08x size = %d\n";
#endif
iter = iter->next;
}
}

3
tools/disasm/n64-jp-1.1/variables.txt
View File

@ -40,8 +40,7 @@ qNaN0x10000 = 0x80098484; // type:f32 size:0x4
sNaN0x3FFFFF = 0x80098488; // size:0x4
D_8009848C_unknown = 0x8009848C;
sRandInt = 0x80098490; // size:0x4
D_80098494_unknown = 0x80098494;
D_800984A0_unknown = 0x800984A0;
gTotalAllocFailures = 0x800984A0; // size:0x4
osViModeNtscHpf1 = 0x800984B0; // size:0x50
osViModePalLan1 = 0x80098500; // size:0x50
D_80098550_unknown = 0x80098550; // type:s16