mirror of
https://github.com/zeldaret/oot.git
synced 2025-07-05 15:34:41 +00:00
First proper commit.
This commit is contained in:
parent
be78236d36
commit
087f561f77
14086 changed files with 1200489 additions and 1 deletions
950
src/code/__osMalloc.c
Normal file
950
src/code/__osMalloc.c
Normal file
|
@ -0,0 +1,950 @@
|
|||
#include <global.h>
|
||||
#include <vt.h>
|
||||
|
||||
#define FILL_ALLOCBLOCK (1 << 0)
|
||||
#define FILL_FREEBLOCK (1 << 1)
|
||||
#define CHECK_FREE_BLOCK (1 << 2)
|
||||
|
||||
#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)
|
||||
|
||||
OSMesg sArenaLockMsg;
|
||||
u32 __osMalloc_FreeBlockTest_Enable;
|
||||
|
||||
bool ArenaImpl_GetFillAllocBlock(Arena* arena)
|
||||
{
|
||||
return (arena->flag & FILL_ALLOCBLOCK) != 0;
|
||||
}
|
||||
bool ArenaImpl_GetFillFreeBlock(Arena* arena)
|
||||
{
|
||||
return (arena->flag & FILL_FREEBLOCK) != 0;
|
||||
}
|
||||
bool ArenaImpl_GetCheckFreeBlock(Arena* arena)
|
||||
{
|
||||
return (arena->flag & CHECK_FREE_BLOCK) != 0;
|
||||
}
|
||||
|
||||
void ArenaImpl_SetFillAllocBlock(Arena* arena)
|
||||
{
|
||||
arena->flag |= FILL_ALLOCBLOCK;
|
||||
}
|
||||
void ArenaImpl_SetFillFreeBlock(Arena* arena)
|
||||
{
|
||||
arena->flag |= FILL_FREEBLOCK;
|
||||
}
|
||||
void ArenaImpl_SetCheckFreeBlock(Arena* arena)
|
||||
{
|
||||
arena->flag |= CHECK_FREE_BLOCK;
|
||||
}
|
||||
|
||||
void ArenaImpl_UnsetFillAllocBlock(Arena* arena)
|
||||
{
|
||||
arena->flag &= ~FILL_ALLOCBLOCK;
|
||||
}
|
||||
void ArenaImpl_UnsetFillFreeBlock(Arena* arena)
|
||||
{
|
||||
arena->flag &= ~FILL_FREEBLOCK;
|
||||
}
|
||||
void ArenaImpl_UnsetCheckFreeBlock(Arena* arena)
|
||||
{
|
||||
arena->flag &= ~CHECK_FREE_BLOCK;
|
||||
}
|
||||
|
||||
void ArenaImpl_SetDebugInfo(ArenaNode* node, const char* file, s32 line, Arena* arena)
|
||||
{
|
||||
node->filename = file;
|
||||
node->line = line;
|
||||
node->threadId = osGetThreadId(NULL);
|
||||
node->arena = arena;
|
||||
node->time = osGetTime();
|
||||
}
|
||||
|
||||
void ArenaImpl_LockInit(Arena* arena)
|
||||
{
|
||||
osCreateMesgQueue(&arena->lock, &sArenaLockMsg, 1);
|
||||
}
|
||||
|
||||
void ArenaImpl_Lock(Arena* arena)
|
||||
{
|
||||
osSendMesg(&arena->lock, NULL, OS_MESG_BLOCK);
|
||||
}
|
||||
|
||||
void ArenaImpl_Unlock(Arena* arena)
|
||||
{
|
||||
osRecvMesg(&arena->lock, NULL, OS_MESG_BLOCK);
|
||||
}
|
||||
|
||||
ArenaNode* ArenaImpl_GetNextBlock(ArenaNode* node)
|
||||
{
|
||||
ArenaNode* ret;
|
||||
|
||||
ret = node->next;
|
||||
if (ret && (!ret || (ret->magic != NODE_MAGIC)))
|
||||
{
|
||||
osSyncPrintf(VT_COL(RED, WHITE) "緊急事態!メモリリーク発見! (block=%08x)\n" VT_RST, ret);
|
||||
ret = NULL;
|
||||
node->next = NULL;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
ArenaNode* ArenaImpl_GetPrevBlock(ArenaNode* node)
|
||||
{
|
||||
ArenaNode* ret;
|
||||
|
||||
ret = node->prev;
|
||||
if (ret && (!ret || (ret->magic != NODE_MAGIC)))
|
||||
{
|
||||
osSyncPrintf(VT_COL(RED, WHITE) "緊急事態!メモリリーク発見! (block=%08x)\n" VT_RST, ret);
|
||||
ret = NULL;
|
||||
node->prev = NULL;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
ArenaNode* ArenaImpl_GetLastBlock(Arena* arena)
|
||||
{
|
||||
ArenaNode* ret = NULL;
|
||||
ArenaNode* iter;
|
||||
|
||||
if (arena && arena->head && arena->head->magic == NODE_MAGIC)
|
||||
{
|
||||
iter = arena->head;
|
||||
while (iter)
|
||||
{
|
||||
ret = iter;
|
||||
iter = ArenaImpl_GetNextBlock(iter);
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
void __osMallocInit(Arena* arena, void* start, u32 size)
|
||||
{
|
||||
bzero(arena, sizeof(Arena));
|
||||
ArenaImpl_LockInit(arena);
|
||||
__osMallocAddBlock(arena, start, size);
|
||||
arena->isInit = true;
|
||||
}
|
||||
|
||||
void __osMallocAddBlock(Arena* arena, void* start, s32 size)
|
||||
{
|
||||
s32 diff;
|
||||
s32 size2;
|
||||
ArenaNode* firstNode;
|
||||
ArenaNode* lastNode;
|
||||
|
||||
if (start)
|
||||
{
|
||||
firstNode = (ArenaNode*)ALIGN16((u32)start);
|
||||
diff = (s32)firstNode - (s32)start;
|
||||
size2 = (size - diff) & ~0xF;
|
||||
if (size2 > (s32)sizeof(ArenaNode))
|
||||
{
|
||||
func_80106860(firstNode, BLOCK_UNINIT_MAGIC, size2); //memset
|
||||
firstNode->next = NULL;
|
||||
firstNode->prev = NULL;
|
||||
firstNode->size = size2 - sizeof(ArenaNode);
|
||||
firstNode->isFree = true;
|
||||
firstNode->magic = NODE_MAGIC;
|
||||
ArenaImpl_Lock(arena);
|
||||
lastNode = ArenaImpl_GetLastBlock(arena);
|
||||
if (!lastNode)
|
||||
{
|
||||
arena->head = firstNode;
|
||||
arena->start = start;
|
||||
}
|
||||
else
|
||||
{
|
||||
firstNode->prev = lastNode;
|
||||
lastNode->next = firstNode;
|
||||
}
|
||||
ArenaImpl_Unlock(arena);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ArenaImpl_RemoveAllBlocks(Arena* arena)
|
||||
{
|
||||
ArenaNode* iter;
|
||||
ArenaNode* next;
|
||||
|
||||
ArenaImpl_Lock(arena);
|
||||
iter = arena->head;
|
||||
while (iter)
|
||||
{
|
||||
next = ArenaImpl_GetNextBlock(iter);
|
||||
func_80106860(iter, BLOCK_UNINIT_MAGIC, iter->size + sizeof(ArenaNode)); //memset
|
||||
iter = next;
|
||||
}
|
||||
|
||||
ArenaImpl_Unlock(arena);
|
||||
}
|
||||
|
||||
void __osMallocCleanup(Arena* arena)
|
||||
{
|
||||
ArenaImpl_RemoveAllBlocks(arena);
|
||||
bzero(arena, sizeof(*arena));
|
||||
}
|
||||
|
||||
u8 __osMallocIsInitalized(Arena* arena)
|
||||
{
|
||||
return arena->isInit;
|
||||
}
|
||||
|
||||
void __osMalloc_FreeBlockTest(Arena *arena, ArenaNode *node)
|
||||
{
|
||||
ArenaNode *node2;
|
||||
u32* start;
|
||||
u32* end;
|
||||
u32* iter;
|
||||
|
||||
node2 = node;
|
||||
|
||||
if (__osMalloc_FreeBlockTest_Enable)
|
||||
{
|
||||
start = (u32*)((u32)node + sizeof(ArenaNode));
|
||||
end = (u32*)((u32) start + node2->size);
|
||||
iter = start;
|
||||
while (iter < end)
|
||||
{
|
||||
if (*iter != BLOCK_UNINIT_MAGIC_32 && *iter != BLOCK_FREE_MAGIC_32)
|
||||
{
|
||||
osSyncPrintf(VT_COL(RED, WHITE) "緊急事態!メモリリーク検出! (block=%08x s=%08x e=%08x p=%08x)\n" VT_RST, node, start, end, iter);
|
||||
__osDisplayArena(arena);
|
||||
return;
|
||||
}
|
||||
iter++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//single instruction not matching, stack problem
|
||||
#ifdef NON_MATCHING
|
||||
void* __osMalloc_NoLockDebug(Arena *arena, u32 size, const char *file, s32 line)
|
||||
{
|
||||
ArenaNode *iter;
|
||||
u32 blockSize;
|
||||
ArenaNode *newNode;
|
||||
void *ret;
|
||||
ArenaNode *next;
|
||||
u32 pad;
|
||||
|
||||
ret = NULL;
|
||||
iter = arena->head;
|
||||
size = ALIGN16(size);
|
||||
while (iter)
|
||||
{
|
||||
if (iter->isFree && iter->size >= size)
|
||||
{
|
||||
if ((arena->flag & CHECK_FREE_BLOCK) != 0)
|
||||
__osMalloc_FreeBlockTest(arena, iter);
|
||||
|
||||
blockSize = ALIGN16(size) + sizeof(ArenaNode);
|
||||
if (blockSize < iter->size)
|
||||
{
|
||||
newNode = (ArenaNode *)((u32)iter + blockSize);
|
||||
newNode->next = ArenaImpl_GetNextBlock(iter);
|
||||
newNode->prev = iter;
|
||||
newNode->size = iter->size - blockSize;
|
||||
newNode->isFree = true;
|
||||
newNode->magic = NODE_MAGIC;
|
||||
|
||||
iter->next = newNode;
|
||||
iter->size = size;
|
||||
next = ArenaImpl_GetNextBlock(newNode);
|
||||
if (next)
|
||||
next->prev = newNode;
|
||||
}
|
||||
|
||||
iter->isFree = false;
|
||||
ArenaImpl_SetDebugInfo(iter, file, line, arena);
|
||||
ret = (void *)((u32)iter + sizeof(ArenaNode));
|
||||
if ((arena->flag & FILL_ALLOCBLOCK) != 0)
|
||||
func_80106860(ret, BLOCK_ALLOC_MAGIC, size);
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
iter = ArenaImpl_GetNextBlock(iter);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
#else
|
||||
#pragma GLOBAL_ASM("asm/non_matchings/code/__osMalloc/__osMalloc_NoLockDebug.s")
|
||||
#endif
|
||||
|
||||
void* __osMallocDebug(Arena* arena, u32 size, const char* file, s32 line)
|
||||
{
|
||||
void* ret;
|
||||
ArenaImpl_Lock(arena);
|
||||
ret = __osMalloc_NoLockDebug(arena, size, file, line);
|
||||
ArenaImpl_Unlock(arena);
|
||||
return ret;
|
||||
}
|
||||
|
||||
//stack + missing a move
|
||||
#ifdef NON_MATCHING
|
||||
void* __osMallocRDebug(Arena *arena, u32 size, const char *file, s32 line)
|
||||
{
|
||||
ArenaNode *iter;
|
||||
u32 blockSize;
|
||||
ArenaNode *newNode;
|
||||
ArenaNode *next;
|
||||
void *ret;
|
||||
|
||||
ret = NULL;
|
||||
size = ALIGN16(size);
|
||||
ArenaImpl_Lock(arena);
|
||||
iter = ArenaImpl_GetLastBlock(arena);;
|
||||
while (iter)
|
||||
{
|
||||
if (iter->isFree && iter->size >= size)
|
||||
{
|
||||
if ((arena->flag & CHECK_FREE_BLOCK) != 0)
|
||||
__osMalloc_FreeBlockTest(arena, iter);
|
||||
|
||||
blockSize = ALIGN16(size) + sizeof(ArenaNode);
|
||||
if (blockSize < iter->size)
|
||||
{
|
||||
newNode = (ArenaNode *)((u32)iter + (iter->size - size));
|
||||
newNode->next = ArenaImpl_GetNextBlock(iter);
|
||||
newNode->prev = iter;
|
||||
newNode->size = size;
|
||||
newNode->magic = NODE_MAGIC;
|
||||
|
||||
iter->next = newNode;
|
||||
iter->size -= blockSize;
|
||||
next = ArenaImpl_GetNextBlock(newNode);
|
||||
if (next)
|
||||
next->prev = newNode;
|
||||
}
|
||||
|
||||
iter->isFree = false;
|
||||
ArenaImpl_SetDebugInfo(iter, file, line, arena);
|
||||
ret = (void *)((u32)iter + sizeof(ArenaNode));
|
||||
if ((arena->flag & FILL_ALLOCBLOCK) != 0)
|
||||
func_80106860(ret, BLOCK_ALLOC_MAGIC, size);
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
iter = ArenaImpl_GetPrevBlock(iter);
|
||||
}
|
||||
|
||||
ArenaImpl_Unlock(arena);
|
||||
return ret;
|
||||
}
|
||||
#else
|
||||
#pragma GLOBAL_ASM("asm/non_matchings/code/__osMalloc/__osMallocRDebug.s")
|
||||
#endif
|
||||
|
||||
|
||||
//same diff as __osMalloc_NoLockDebug
|
||||
#ifdef NON_MATCHING
|
||||
void* __osMalloc_NoLock(Arena *arena, u32 size)
|
||||
{
|
||||
ArenaNode *iter;
|
||||
u32 blockSize;
|
||||
ArenaNode *newNode;
|
||||
void *ret;
|
||||
ArenaNode *next;
|
||||
u32 pad;
|
||||
|
||||
ret = NULL;
|
||||
iter = arena->head;
|
||||
size = ALIGN16(size);
|
||||
while (iter)
|
||||
{
|
||||
if (iter->isFree && iter->size >= size)
|
||||
{
|
||||
if ((arena->flag & CHECK_FREE_BLOCK) != 0)
|
||||
__osMalloc_FreeBlockTest(arena, iter);
|
||||
|
||||
blockSize = ALIGN16(size) + sizeof(ArenaNode);
|
||||
if (blockSize < iter->size)
|
||||
{
|
||||
newNode = (ArenaNode *)((u32)iter + blockSize);
|
||||
newNode->next = ArenaImpl_GetNextBlock(iter);
|
||||
newNode->prev = iter;
|
||||
newNode->size = iter->size - blockSize;
|
||||
newNode->isFree = true;
|
||||
newNode->magic = NODE_MAGIC;
|
||||
|
||||
iter->next = newNode;
|
||||
iter->size = size;
|
||||
next = ArenaImpl_GetNextBlock(newNode);
|
||||
if (next)
|
||||
next->prev = newNode;
|
||||
}
|
||||
|
||||
iter->isFree = false;
|
||||
ArenaImpl_SetDebugInfo(iter, NULL, 0, arena);
|
||||
ret = (void *)((u32)iter + sizeof(ArenaNode));
|
||||
if ((arena->flag & FILL_ALLOCBLOCK) != 0)
|
||||
func_80106860(ret, BLOCK_ALLOC_MAGIC, size);
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
iter = ArenaImpl_GetNextBlock(iter);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
#else
|
||||
#pragma GLOBAL_ASM("asm/non_matchings/code/__osMalloc/__osMalloc_NoLock.s")
|
||||
#endif
|
||||
|
||||
void* __osMalloc(Arena* arena, u32 size)
|
||||
{
|
||||
void* ret;
|
||||
ArenaImpl_Lock(arena);
|
||||
ret = __osMalloc_NoLock(arena, size);
|
||||
ArenaImpl_Unlock(arena);
|
||||
return ret;
|
||||
}
|
||||
|
||||
//same diff as __osMallocRDebug
|
||||
#ifdef NON_MATCHING
|
||||
void* __osMallocR(Arena *arena, u32 size)
|
||||
{
|
||||
ArenaNode *iter;
|
||||
u32 blockSize;
|
||||
ArenaNode *newNode;
|
||||
ArenaNode *next;
|
||||
void *ret;
|
||||
|
||||
ret = NULL;
|
||||
size = ALIGN16(size);
|
||||
ArenaImpl_Lock(arena);
|
||||
iter = ArenaImpl_GetLastBlock(arena);;
|
||||
while (iter)
|
||||
{
|
||||
if (iter->isFree && iter->size >= size)
|
||||
{
|
||||
if ((arena->flag & CHECK_FREE_BLOCK) != 0)
|
||||
__osMalloc_FreeBlockTest(arena, iter);
|
||||
|
||||
blockSize = ALIGN16(size) + sizeof(ArenaNode);
|
||||
if (blockSize < iter->size)
|
||||
{
|
||||
newNode = (ArenaNode *)((u32)iter + (iter->size - size));
|
||||
newNode->next = ArenaImpl_GetNextBlock(iter);
|
||||
newNode->prev = iter;
|
||||
newNode->size = size;
|
||||
newNode->magic = NODE_MAGIC;
|
||||
|
||||
iter->next = newNode;
|
||||
iter->size -= blockSize;
|
||||
next = ArenaImpl_GetNextBlock(newNode);
|
||||
if (next)
|
||||
next->prev = newNode;
|
||||
}
|
||||
|
||||
iter->isFree = false;
|
||||
ArenaImpl_SetDebugInfo(iter, NULL, 0, arena);
|
||||
ret = (void *)((u32)iter + sizeof(ArenaNode));
|
||||
if ((arena->flag & FILL_ALLOCBLOCK) != 0)
|
||||
func_80106860(ret, BLOCK_ALLOC_MAGIC, size);
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
iter = ArenaImpl_GetPrevBlock(iter);
|
||||
}
|
||||
|
||||
ArenaImpl_Unlock(arena);
|
||||
return ret;
|
||||
}
|
||||
#else
|
||||
#pragma GLOBAL_ASM("asm/non_matchings/code/__osMalloc/__osMallocR.s")
|
||||
#endif
|
||||
|
||||
|
||||
//small reordering
|
||||
#ifdef NON_MATCHING
|
||||
void __osFree_NoLock(Arena* arena, void* ptr)
|
||||
{
|
||||
ArenaNode* node;
|
||||
ArenaNode* next;
|
||||
ArenaNode* prev;
|
||||
ArenaNode* newNext;
|
||||
|
||||
if (ptr)
|
||||
{
|
||||
node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
|
||||
if (node == NULL || node->magic != NODE_MAGIC)
|
||||
{
|
||||
osSyncPrintf(VT_COL(RED, WHITE) "__osFree:不正解放(%08x)\n" VT_RST, arena); //__osFree: Unauthorized release (%08x)
|
||||
return;
|
||||
}
|
||||
if (node->isFree)
|
||||
{
|
||||
osSyncPrintf(VT_COL(RED, WHITE) "__osFree:二重解放(%08x)\n" VT_RST, arena); //__osFree: Double release (%08x)
|
||||
return;
|
||||
}
|
||||
if (arena != node->arena && arena != NULL)
|
||||
{
|
||||
//__osFree:Tried to release in a different way than when it was secured (%08x:%08x)
|
||||
osSyncPrintf(VT_COL(RED, WHITE) "__osFree:確保時と違う方法で解放しようとした (%08x:%08x)\n" VT_RST, arena, node->arena);
|
||||
return;
|
||||
}
|
||||
|
||||
next = ArenaImpl_GetNextBlock(node);
|
||||
prev = ArenaImpl_GetPrevBlock(node);
|
||||
node->isFree = true;
|
||||
ArenaImpl_SetDebugInfo(node, NULL, 0, arena);
|
||||
if ((arena->flag & FILL_FREEBLOCK) != 0)
|
||||
{
|
||||
func_80106860((u32)node + sizeof(ArenaNode), BLOCK_FREE_MAGIC, node->size);
|
||||
}
|
||||
|
||||
newNext = node->next;
|
||||
if ((u32)next == (u32)node + sizeof(ArenaNode) + node->size && next->isFree)
|
||||
{
|
||||
newNext = ArenaImpl_GetNextBlock(next);
|
||||
if (newNext)
|
||||
newNext->prev = node;
|
||||
|
||||
node->size += next->size + sizeof(ArenaNode);
|
||||
if ((arena->flag & FILL_FREEBLOCK) != 0)
|
||||
func_80106860(next, BLOCK_FREE_MAGIC, sizeof(ArenaNode));
|
||||
node->next = newNext;
|
||||
}
|
||||
if (prev && prev->isFree && (u32)node == (u32)prev + sizeof(ArenaNode) + prev->size)
|
||||
{
|
||||
if (newNext)
|
||||
newNext->prev = prev;
|
||||
prev->next = newNext;
|
||||
prev->size += node->size + sizeof(ArenaNode);
|
||||
if ((arena->flag & FILL_FREEBLOCK) != 0)
|
||||
func_80106860(node, BLOCK_FREE_MAGIC, sizeof(ArenaNode));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
#else
|
||||
#pragma GLOBAL_ASM("asm/non_matchings/code/__osMalloc/__osFree_NoLock.s")
|
||||
#endif
|
||||
|
||||
void __osFree(Arena* arena, void* ptr)
|
||||
{
|
||||
ArenaImpl_Lock(arena);
|
||||
__osFree_NoLock(arena, ptr);
|
||||
ArenaImpl_Unlock(arena);
|
||||
}
|
||||
|
||||
//small reordering
|
||||
#ifdef NON_MATCHING
|
||||
void __osFree_NoLockDebug(Arena* arena, void* ptr, const char* file, s32 line)
|
||||
{
|
||||
ArenaNode* node;
|
||||
ArenaNode* next;
|
||||
ArenaNode* prev;
|
||||
ArenaNode* newNext;
|
||||
|
||||
if (ptr)
|
||||
{
|
||||
node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
|
||||
if (node == NULL || node->magic != NODE_MAGIC)
|
||||
{
|
||||
osSyncPrintf(VT_COL(RED, WHITE) "__osFree:不正解放(%08x) [%s:%d ]\n" VT_RST, arena, file, line); //__osFree: Unauthorized release (%08x)
|
||||
return;
|
||||
}
|
||||
if (node->isFree)
|
||||
{
|
||||
osSyncPrintf(VT_COL(RED, WHITE) "__osFree:二重解放(%08x)\n" VT_RST, arena); //__osFree: Double release (%08x)
|
||||
return;
|
||||
}
|
||||
if (arena != node->arena && arena != NULL)
|
||||
{
|
||||
//__osFree:Tried to release in a different way than when it was secured (%08x:%08x)
|
||||
osSyncPrintf(VT_COL(RED, WHITE) "__osFree:確保時と違う方法で解放しようとした (%08x:%08x)\n" VT_RST, arena, node->arena);
|
||||
return;
|
||||
}
|
||||
|
||||
next = ArenaImpl_GetNextBlock(node);
|
||||
prev = ArenaImpl_GetPrevBlock(node);
|
||||
node->isFree = true;
|
||||
ArenaImpl_SetDebugInfo(node, file, line, arena);
|
||||
if ((arena->flag & FILL_FREEBLOCK) != 0)
|
||||
{
|
||||
func_80106860((u32)node + sizeof(ArenaNode), BLOCK_FREE_MAGIC, node->size);
|
||||
}
|
||||
|
||||
newNext = node->next;
|
||||
if ((u32)next == (u32)node + sizeof(ArenaNode) + node->size && next->isFree)
|
||||
{
|
||||
newNext = ArenaImpl_GetNextBlock(next);
|
||||
if (newNext)
|
||||
newNext->prev = node;
|
||||
|
||||
node->size += next->size + sizeof(ArenaNode);
|
||||
if ((arena->flag & FILL_FREEBLOCK) != 0)
|
||||
func_80106860(next, BLOCK_FREE_MAGIC, sizeof(ArenaNode));
|
||||
node->next = newNext;
|
||||
}
|
||||
if (prev && prev->isFree && (u32)node == (u32)prev + sizeof(ArenaNode) + prev->size)
|
||||
{
|
||||
if (newNext)
|
||||
newNext->prev = prev;
|
||||
prev->next = newNext;
|
||||
prev->size += node->size + sizeof(ArenaNode);
|
||||
if ((arena->flag & FILL_FREEBLOCK) != 0)
|
||||
func_80106860(node, BLOCK_FREE_MAGIC, sizeof(ArenaNode));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
#else
|
||||
#pragma GLOBAL_ASM("asm/non_matchings/code/__osMalloc/__osFree_NoLockDebug.s")
|
||||
#endif
|
||||
|
||||
void __osFreeDebug(Arena* arena, void* ptr, const char* file, s32 line)
|
||||
{
|
||||
ArenaImpl_Lock(arena);
|
||||
__osFree_NoLockDebug(arena, ptr, file, line);
|
||||
ArenaImpl_Unlock(arena);
|
||||
}
|
||||
|
||||
//small reordering, stack usage
|
||||
#ifdef NON_MATCHING
|
||||
void* __osRealloc(Arena* arena, void* ptr, u32 newSize)
|
||||
{
|
||||
ArenaNode* node;
|
||||
ArenaNode* next;
|
||||
u32 sizeDiff;
|
||||
ArenaNode* overNext;
|
||||
ArenaNode* newNext;
|
||||
void* newAlloc;
|
||||
//-----------
|
||||
ArenaNode* next2;
|
||||
ArenaNode unk;
|
||||
ArenaNode* newNext2;
|
||||
ArenaNode* overNext2;
|
||||
//----------
|
||||
u32 newSize2;
|
||||
ArenaNode* newNext3;
|
||||
ArenaNode* overNext3;
|
||||
|
||||
|
||||
newSize = ALIGN16(newSize);
|
||||
osSyncPrintf("__osRealloc(%08x, %d)\n", ptr, newSize);
|
||||
ArenaImpl_Lock(arena);
|
||||
if (!ptr)
|
||||
{
|
||||
ptr = __osMalloc(arena, newSize);
|
||||
}
|
||||
else if (!newSize)
|
||||
{
|
||||
__osFree_NoLock(arena, ptr);
|
||||
ptr = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
node = (ArenaNode*)((u32)ptr - sizeof(ArenaNode));
|
||||
if (newSize == node->size)
|
||||
{
|
||||
//Does nothing because the memory block size does not change
|
||||
osSyncPrintf("メモリブロックサイズが変わらないためなにもしません\n");
|
||||
}
|
||||
else if (node->size < newSize)
|
||||
{
|
||||
next = ArenaImpl_GetNextBlock(node);
|
||||
sizeDiff = newSize - node->size;
|
||||
if ((u32)next == ((u32)node + node->size + sizeof(ArenaNode)) && next->isFree && next->size >= sizeDiff)
|
||||
{
|
||||
//Merge because there is a free block after the current memory block
|
||||
osSyncPrintf("現メモリブロックの後ろにフリーブロックがあるので結合します\n");
|
||||
next->size -= sizeDiff;
|
||||
overNext = ArenaImpl_GetNextBlock(next);
|
||||
newNext = (ArenaNode*)((u32)next + sizeDiff);
|
||||
if (overNext)
|
||||
overNext->prev = newNext;
|
||||
node->next = newNext;
|
||||
node->size = newSize;
|
||||
func_801068B0(newNext, next, sizeof(ArenaNode)); //memcpy
|
||||
}
|
||||
else
|
||||
{
|
||||
//Allocate a new memory block and move the contents
|
||||
osSyncPrintf("新たにメモリブロックを確保して内容を移動します\n");
|
||||
newAlloc = __osMalloc_NoLock(arena, newSize);
|
||||
if (newAlloc)
|
||||
{
|
||||
bcopy(ptr, newAlloc, node->size);
|
||||
__osFree_NoLock(arena, ptr);
|
||||
}
|
||||
ptr = newAlloc;
|
||||
}
|
||||
}
|
||||
else if (newSize < node->size)
|
||||
{
|
||||
next2 = ArenaImpl_GetNextBlock(node);
|
||||
if (next && next->isFree)
|
||||
{
|
||||
//Increased free block behind current memory block
|
||||
osSyncPrintf("現メモリブロックの後ろのフリーブロックを大きくしました\n");
|
||||
unk = *next2;
|
||||
newNext2 = (u32)node + ALIGN16(newSize) + sizeof(ArenaNode);
|
||||
*newNext2 = unk;
|
||||
newNext2->size += node->size - newSize;
|
||||
node->next = newNext2;
|
||||
node->size = newSize;
|
||||
overNext2 = ArenaImpl_GetNextBlock(newNext2);
|
||||
if (overNext2)
|
||||
overNext2->prev = newNext2;
|
||||
}
|
||||
else if (newSize + sizeof(ArenaNode) < node->size)
|
||||
{
|
||||
//Generated because there is no free block after the current memory block
|
||||
osSyncPrintf("現メモリブロックの後ろにフリーブロックがないので生成します\n");
|
||||
newSize2 = ALIGN16(newSize) + sizeof(ArenaNode);
|
||||
newNext3 = (ArenaNode*)((u32)node + newSize2);
|
||||
newNext3->next = ArenaImpl_GetNextBlock(node);
|
||||
newNext3->prev = node;
|
||||
newNext3->size = node->size - newSize2;
|
||||
newNext3->isFree = true;
|
||||
newNext3->magic = NODE_MAGIC;
|
||||
node->next = newNext3;
|
||||
node->size = newSize;
|
||||
overNext3 = ArenaImpl_GetNextBlock(newNext3);
|
||||
if (overNext3)
|
||||
overNext3->prev = newNext3;
|
||||
}
|
||||
else
|
||||
{
|
||||
//There is no room to generate free blocks
|
||||
osSyncPrintf("フリーブロック生成するだけの空きがありません\n");
|
||||
ptr = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
ArenaImpl_Unlock(arena);
|
||||
return ptr;
|
||||
}
|
||||
#else
|
||||
#pragma GLOBAL_ASM("asm/non_matchings/code/__osMalloc/__osRealloc.s")
|
||||
#endif
|
||||
|
||||
void* __osReallocDebug(Arena* arena, void* ptr, u32 newSize, const char* file, s32 line)
|
||||
{
|
||||
return __osRealloc(arena, ptr, newSize);
|
||||
}
|
||||
|
||||
void ArenaImpl_GetSizes(Arena* arena, u32* outMaxFree, u32* outFree, u32* outAlloc)
|
||||
{
|
||||
ArenaNode* iter;
|
||||
|
||||
ArenaImpl_Lock(arena);
|
||||
|
||||
*outMaxFree = 0;
|
||||
*outFree = 0;
|
||||
*outAlloc = 0;
|
||||
|
||||
iter = arena->head;
|
||||
while(iter)
|
||||
{
|
||||
if (iter->isFree)
|
||||
{
|
||||
*outFree += iter->size;
|
||||
if (*outMaxFree < iter->size)
|
||||
*outMaxFree = iter->size;
|
||||
}
|
||||
else
|
||||
*outAlloc += iter->size;
|
||||
|
||||
iter = ArenaImpl_GetNextBlock(iter);
|
||||
}
|
||||
|
||||
ArenaImpl_Unlock(arena);
|
||||
}
|
||||
|
||||
//small reordering at the end
|
||||
#ifdef NON_MATCHING
|
||||
void __osDisplayArena(Arena* arena)
|
||||
{
|
||||
u32 freeSize;
|
||||
u32 allocatedSize;
|
||||
u32 maxFree;
|
||||
ArenaNode* iter;
|
||||
ArenaNode* next;
|
||||
|
||||
if (!__osMallocIsInitalized(arena))
|
||||
{
|
||||
//Arena is not initalized
|
||||
osSyncPrintf("アリーナは初期化されていません\n");
|
||||
return;
|
||||
}
|
||||
|
||||
ArenaImpl_Lock(arena);
|
||||
|
||||
maxFree = 0;
|
||||
freeSize = 0;
|
||||
allocatedSize = 0;
|
||||
|
||||
//Arena contents (0x%08x)
|
||||
osSyncPrintf("アリーナの内容 (0x%08x)\n", arena);
|
||||
//Memory node range status size [time s ms us ns: TID: src: line]
|
||||
osSyncPrintf("メモリブロック範囲 status サイズ [時刻 s ms us ns: TID:src:行]\n");
|
||||
|
||||
iter = arena->head;
|
||||
while(iter)
|
||||
{
|
||||
if (iter && iter->magic == NODE_MAGIC)
|
||||
{
|
||||
next = iter->next;
|
||||
osSyncPrintf("%08x-%08x%c %s %08x", iter, ((u32)iter + sizeof(ArenaNode) + iter->size),
|
||||
(!next) ? '$' : (iter != next->prev ? '!' : ' '),
|
||||
iter->isFree ? "空き" : "確保", //? "Free" : "Secure"
|
||||
iter->size);
|
||||
|
||||
if (!iter->isFree)
|
||||
osSyncPrintf(" [%016llu:%2d:%s:%d]", (iter->time*64ll)/3ull, iter->threadId, iter->filename ? iter->filename : "**NULL**", iter->line);
|
||||
|
||||
osSyncPrintf("\n");
|
||||
|
||||
if (iter->isFree)
|
||||
{
|
||||
freeSize += iter->size;
|
||||
if (maxFree < iter->size)
|
||||
maxFree = iter->size;
|
||||
}
|
||||
else
|
||||
{
|
||||
allocatedSize += iter->size;
|
||||
}
|
||||
|
||||
iter = next;
|
||||
}
|
||||
else
|
||||
{
|
||||
osSyncPrintf("%08x Block Invalid\n", iter);
|
||||
iter = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
osSyncPrintf("確保ブロックサイズの合計 0x%08x バイト\n", allocatedSize); //Total reserved node size 0x%08x bytes
|
||||
osSyncPrintf("空きブロックサイズの合計 0x%08x バイト\n", freeSize); //Total free node size 0x%08x bytes
|
||||
osSyncPrintf("最大空きブロックサイズ 0x%08x バイト\n", maxFree); //Maximum free node size 0x%08x bytes
|
||||
|
||||
ArenaImpl_Unlock(arena);
|
||||
}
|
||||
#else
|
||||
#pragma GLOBAL_ASM("asm/non_matchings/code/__osMalloc/__osDisplayArena.s")
|
||||
#endif
|
||||
|
||||
//small reordering
|
||||
#ifdef NON_MATCHING
|
||||
void ArenaImpl_FaultClient(Arena* arena)
|
||||
{
|
||||
u32 freeSize;
|
||||
u32 allocatedSize;
|
||||
u32 maxFree;
|
||||
ArenaNode* iter;
|
||||
ArenaNode* next;
|
||||
|
||||
FaultDrawer_Printf("ARENA INFO (0x%08x)\n", arena);
|
||||
if (!__osMallocIsInitalized(arena))
|
||||
{
|
||||
FaultDrawer_Printf("Arena is uninitalized\n", arena);
|
||||
return;
|
||||
}
|
||||
|
||||
maxFree = 0;
|
||||
freeSize = 0;
|
||||
allocatedSize = 0;
|
||||
|
||||
FaultDrawer_Printf("Memory Block Region status size\n");
|
||||
|
||||
iter = arena->head;
|
||||
while(iter)
|
||||
{
|
||||
if (iter && iter->magic == NODE_MAGIC)
|
||||
{
|
||||
next = iter->next;
|
||||
FaultDrawer_Printf("%08x-%08x%c %s %08x", iter, ((u32)iter + sizeof(ArenaNode) + iter->size),
|
||||
(!next) ? '$' : (iter != next->prev ? '!' : ' '),
|
||||
iter->isFree ? "F" : "A",
|
||||
iter->size);
|
||||
|
||||
FaultDrawer_Printf("\n");
|
||||
|
||||
if (iter->isFree)
|
||||
{
|
||||
freeSize += iter->size;
|
||||
if (maxFree < iter->size)
|
||||
maxFree = iter->size;
|
||||
}
|
||||
else
|
||||
{
|
||||
allocatedSize += iter->size;
|
||||
}
|
||||
|
||||
iter = next;
|
||||
}
|
||||
else
|
||||
{
|
||||
FaultDrawer_SetFontColor(0xF801);
|
||||
FaultDrawer_Printf("%08x Block Invalid\n", iter);
|
||||
iter = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
FaultDrawer_SetFontColor(0x7F1);
|
||||
FaultDrawer_Printf("Total Alloc Block Size %08x\n", allocatedSize);
|
||||
FaultDrawer_Printf("Total Free Block Size %08x\n", freeSize);
|
||||
FaultDrawer_Printf("Largest Free Block Size %08x\n", maxFree);
|
||||
}
|
||||
#else
|
||||
#pragma GLOBAL_ASM("asm/non_matchings/code/__osMalloc/ArenaImpl_FaultClient.s")
|
||||
#endif
|
||||
|
||||
u32 __osCheckArena(Arena* arena)
|
||||
{
|
||||
ArenaNode *iter;
|
||||
u32 error;
|
||||
|
||||
error = 0;
|
||||
ArenaImpl_Lock(arena);
|
||||
//Checking the contents of the arena. . . (%08x)
|
||||
osSyncPrintf("アリーナの内容をチェックしています... (%08x)\n", arena);
|
||||
iter = arena->head;
|
||||
while(iter)
|
||||
{
|
||||
if (iter && iter->magic == NODE_MAGIC)
|
||||
{
|
||||
//Oops!! (%08x %08x)
|
||||
osSyncPrintf(VT_COL(RED, WHITE) "おおっと!! (%08x %08x)\n" VT_RST, iter, iter->magic);
|
||||
error = 1;
|
||||
break;
|
||||
}
|
||||
iter = ArenaImpl_GetNextBlock(iter);
|
||||
}
|
||||
if (!error)
|
||||
{
|
||||
//The arena is still going well
|
||||
osSyncPrintf("アリーナはまだ、いけそうです\n");
|
||||
}
|
||||
ArenaImpl_Unlock(arena);
|
||||
return error;
|
||||
}
|
||||
|
||||
u8 func_800FF334(Arena* arena)
|
||||
{
|
||||
return arena->unk_20;
|
||||
}
|
Loading…
Add table
Add a link
Reference in a new issue