weirdbeardgame/Mulberry
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleaned up line numbers and needless comments

Browse Source
This commit is contained in:
weirdbeardgame
2026-09-03 17:36:49 -05:00
parent 253e3d670e
commit 28845953e0
1 changed files with 244 additions and 457 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/cs4/Seimei/src/Memory.c
+70 -283
View File
@@ -1,5 +1,5 @@
#include "common.h"
#include "Memory.h" #include "Memory.h"
#include "common.h"
u_int UseMemSize; u_int UseMemSize;
u_int MaxHeapSize; u_int MaxHeapSize;
@@ -7,162 +7,77 @@ u_int LastAddr;
static int FixMemEndIndex; static int FixMemEndIndex;
allocmng AllocMng[2048]; allocmng AllocMng[2048];
inline int MemGetHeapSize() #define ONE_KB (1024)
{ #define ONE_MB (ONE_KB * ONE_KB)
#define MAX_RAM (32 * ONE_MB)
#define VALUE_0 (4 * ONE_KB)
#define VALUE_1 (80 * ONE_KB)
inline int MemGetHeapSize() {
int ret; int ret;
memset(&AllocMng, 0, sizeof(AllocMng)); memset(&AllocMng, 0, sizeof(AllocMng));
ret = (unsigned int)&_end + ((unsigned int)&_stack_size + 0x1000); ret = (unsigned int)&_end + ((unsigned int)&_stack_size + VALUE_0);
ret += 0x14000; ret += VALUE_1;
return 0x2000000 - ret; return MAX_RAM - ret;
} }
inline allocmng *MemSetLP(void * lp, allocmng *temp_v1, int size) inline allocmng *MemSetLP(void *lp, allocmng *temp_v1, int size) {
{
int i; int i;
if (lp == 0) { if (lp == 0) {
return 0; return 0;
} }
temp_v1 = &AllocMng[0]; temp_v1 = &AllocMng[0];
for (i = 0; temp_v1 != &AllocMng[2048]; temp_v1++) for (i = 0; temp_v1 != &AllocMng[2048]; temp_v1++) {
{ if (!temp_v1->bUse) {
if (!temp_v1->bUse)
{
temp_v1->bUse = 1; temp_v1->bUse = 1;
temp_v1->addr = (u_int)lp; temp_v1->addr = (u_int)lp;
temp_v1->size = size; temp_v1->size = size;
return temp_v1; return temp_v1;
} }
// temp_v1++;
} }
return 0; return 0;
} }
void MemInit(void) {
void *lp;
void MemInit(void)
{
void* lp;
allocmng *temp_v1 = AllocMng; allocmng *temp_v1 = AllocMng;
int sz = MemGetHeapSize() - 0x10; int sz = MemGetHeapSize() - 0x10;
lp = (void *)malloc(sz); lp = (void *)malloc(sz);
LastAddr = (int)lp + sz; LastAddr = (int)lp + sz;
temp_v1 = MemSetLP(lp, temp_v1, sz); temp_v1 = MemSetLP(lp, temp_v1, sz);
temp_v1->addrB = temp_v1->addr; temp_v1->addrB = temp_v1->addr;
UseMemSize = 0; UseMemSize = 0;
MaxHeapSize = sz; MaxHeapSize = sz;
} }
void *MemAllocReal(unsigned int size /* r11 */, char *lpFuncName /* r5 */,
char *lpUseName /* r2 */) {
void *lpAddr; // r2
if (size == 0) {
return NULL;
}
void * MemAllocReal(unsigned int size /* r11 */, char * lpFuncName /* r5 */, char * lpUseName /* r2 */)
{
void * lpAddr; // r2
if (size == 0) return NULL;
lpAddr = AllocateMemory(size, 0x10, lpFuncName, lpUseName); lpAddr = AllocateMemory(size, 0x10, lpFuncName, lpUseName);
UseMemSize += size; UseMemSize += size;
return lpAddr; return lpAddr;
} }
void *MemAllocAlignReal(unsigned int size /* r11 */,
unsigned int align /* r2 */, char *lpFuncName /* r2 */,
char *lpUseName /* r2 */) {
void *lpAddr; // r2
if (size == 0) {
return NULL;
}
void * MemAllocAlignReal(unsigned int size /* r11 */, unsigned int align /* r2 */, char * lpFuncName /* r2 */, char * lpUseName /* r2 */)
{
void * lpAddr; // r2
if (size == 0) return NULL;
lpAddr = AllocateMemory(size, align, lpFuncName, lpUseName); lpAddr = AllocateMemory(size, align, lpFuncName, lpUseName);
UseMemSize += size; UseMemSize += size;
return lpAddr; return lpAddr;
} }
@@ -173,22 +88,16 @@ void * MemAllocAlignReal(unsigned int size /* r11 */, unsigned int align /* r2 *
Language: C Language: C
Code range: 0x0014AF40 -> 0x0014AF6C Code range: 0x0014AF40 -> 0x0014AF6C
*/ */
void MemFree(void * lpMem /* r2 */) { void MemFree(void *lpMem /* r2 */) {
if (lpMem != NULL) { if (lpMem != NULL) {
UseMemSize -= FreeMemory(lpMem); UseMemSize -= FreeMemory(lpMem);
} }
} }
static inline allocmng *getLpBaseMng(u_int size, u_int align) { // or macro? static inline allocmng *getLpBaseMng(u_int size, u_int align) { // or macro?
allocmng * lpBaseMng; allocmng *lpBaseMng;
unsigned int AlignAddr; unsigned int AlignAddr;
unsigned int AlignSize; unsigned int AlignSize;
unsigned int OldEndAddr; unsigned int OldEndAddr;
@@ -213,7 +122,7 @@ static inline allocmng *getLpBaseMng(u_int size, u_int align) { // or macro?
} }
static inline allocmng *findUnusedAllocMng() { // or macro? static inline allocmng *findUnusedAllocMng() { // or macro?
allocmng * lpBaseMng; allocmng *lpBaseMng;
lpBaseMng = AllocMng; lpBaseMng = AllocMng;
@@ -232,12 +141,14 @@ static inline allocmng *findUnusedAllocMng() { // or macro?
return lpBaseMng; return lpBaseMng;
} }
static inline allocmng *findUnusedAllocMngAligned(u_int size, unsigned int align) { // or macro? static inline allocmng *findUnusedAllocMngAligned(u_int size,
allocmng * lpBaseMng; unsigned int align) {
allocmng *lpBaseMng;
if (align == 0) { if (align == 0) {
lpBaseMng = NULL; lpBaseMng = NULL;
} else { } else {
lpBaseMng = AllocMng; lpBaseMng = AllocMng;
while (1) { while (1) {
if (lpBaseMng->bUse == 0) { if (lpBaseMng->bUse == 0) {
lpBaseMng->bUse = 1; lpBaseMng->bUse = 1;
@@ -256,105 +167,17 @@ static inline allocmng *findUnusedAllocMngAligned(u_int size, unsigned int align
return lpBaseMng; return lpBaseMng;
} }
static inline int getAlignedAddress(int addr, volatile int align) { // ??? static inline int getAlignedAddress(int addr, volatile int align) {
return (addr + align - 1) & ~(align - 1); return (addr + align - 1) & ~(align - 1);
} }
/* /*
Compile unit: C:\cs4\Seimei\src\Memory.c Compile unit: C:\cs4\Seimei\src\Memory.c
Producer: MW MIPS C Compiler Producer: MW MIPS C Compiler
Language: C Language: C
Code range: 0x0014AF20 -> 0x0014AF34 Code range: 0x0014AF20 -> 0x0014AF34
*/ */
void SetFixMemoryEndIndex(void) { void SetFixMemoryEndIndex(void) { FixMemEndIndex = AllocMng->prev->no; }
FixMemEndIndex = AllocMng->prev->no;
}
/* /*
Compile unit: C:\cs4\Seimei\src\Memory.c Compile unit: C:\cs4\Seimei\src\Memory.c
@@ -362,21 +185,18 @@ void SetFixMemoryEndIndex(void) {
Language: C Language: C
Code range: 0x0014AD00 -> 0x0014AF20 Code range: 0x0014AD00 -> 0x0014AF20
*/ */
static void * AllocateMemory(u_int size /* r2 */, u_int align /* r2 */, char * lpFuncName /* r2 */, char * lpUseName) static void *AllocateMemory(u_int size /* r2 */, u_int align /* r2 */,
{ char *lpFuncName /* r2 */, char *lpUseName) {
// Range: 0x14AD00 -> 0x14AF20 // Range: 0x14AD00 -> 0x14AF20
allocmng * lpBaseMng; // r9 $t1 allocmng *lpBaseMng; // r9 $t1
unsigned int AlignAddr; // r10 $t2 unsigned int AlignAddr; // r10 $t2
unsigned int AlignSize; // r8 $t0 unsigned int AlignSize; // r8 $t0
unsigned int OldEndAddr; // r9 $t1 unsigned int OldEndAddr; // r9 $t1
allocmng* var_t0; allocmng *var_t0;
u_int temp_v0, temp_a3; u_int temp_v0, temp_a3;
if ((lpBaseMng = getLpBaseMng(size, align)) != NULL) { if ((lpBaseMng = getLpBaseMng(size, align)) != NULL) {
lpBaseMng->bFree = 0; lpBaseMng->bFree = 0;
AlignAddr = getAlignedAddress(lpBaseMng->addrB, align); AlignAddr = getAlignedAddress(lpBaseMng->addrB, align);
@@ -387,14 +207,9 @@ static void * AllocateMemory(u_int size /* r2 */, u_int align /* r2 */, char * l
lpBaseMng->addr = AlignAddr; lpBaseMng->addr = AlignAddr;
lpBaseMng->size = size; lpBaseMng->size = size;
lpBaseMng->lpfuncname = lpFuncName; lpBaseMng->lpfuncname = lpFuncName;
return (void *)lpBaseMng->addr; return (void *)lpBaseMng->addr;
} }
var_t0 = findUnusedAllocMng(); var_t0 = findUnusedAllocMng();
var_t0->addr = temp_a3; var_t0->addr = temp_a3;
var_t0->addrB = var_t0->addr; var_t0->addrB = var_t0->addr;
@@ -409,40 +224,21 @@ static void * AllocateMemory(u_int size /* r2 */, u_int align /* r2 */, char * l
lpBaseMng->addr = AlignAddr; lpBaseMng->addr = AlignAddr;
lpBaseMng->size = size; lpBaseMng->size = size;
lpBaseMng->lpfuncname = lpFuncName; lpBaseMng->lpfuncname = lpFuncName;
return (void *)lpBaseMng->addr; return (void *)lpBaseMng->addr;
} }
// Line Numbers suggest bad instruction in inline function
var_t0 = AllocMng; var_t0 = AllocMng;
AlignAddr = getAlignedAddress(var_t0->addr, align); AlignAddr = getAlignedAddress(var_t0->addr, align);
temp_v0 = (AlignAddr - var_t0->addr); temp_v0 = (AlignAddr - var_t0->addr);
lpBaseMng = findUnusedAllocMngAligned(size, AlignAddr); lpBaseMng = findUnusedAllocMngAligned(size, AlignAddr);
lpBaseMng->addrB = var_t0->addr; lpBaseMng->addrB = var_t0->addr;
lpBaseMng->lpfuncname = lpFuncName; lpBaseMng->lpfuncname = lpFuncName;
var_t0->addr = AlignAddr + size; var_t0->addr = AlignAddr + size;
var_t0->addrB = var_t0->addr; var_t0->addrB = var_t0->addr;
var_t0->size -= size + temp_v0; var_t0->size -= size + temp_v0;
if (var_t0->prev != NULL) { if (var_t0->prev != NULL) {
var_t0->prev->next = lpBaseMng; var_t0->prev->next = lpBaseMng;
lpBaseMng->prev = var_t0->prev; lpBaseMng->prev = var_t0->prev;
@@ -450,52 +246,48 @@ static void * AllocateMemory(u_int size /* r2 */, u_int align /* r2 */, char * l
var_t0->prev = lpBaseMng; var_t0->prev = lpBaseMng;
lpBaseMng->next = var_t0; lpBaseMng->next = var_t0;
return (void *)lpBaseMng->addr;
return (void* ) lpBaseMng->addr;
} }
static u_int FreeMemory(void * lpMem /* r2 */) static u_int FreeMemory(void *lpMem /* r2 */) {
{ allocmng *lpBaseMng;
allocmng * lpBaseMng; allocmng * lpAllocMng; allocmng *lpAllocMng;
allocmng * lpLinkMng; allocmng *lpLinkMng;
unsigned int FreeAddr; unsigned int FreeAddr;
unsigned int EndAddr; unsigned int EndAddr;
unsigned int FreeSize; unsigned int FreeSize;
lpBaseMng = AllocMng; lpBaseMng = AllocMng;
for (lpAllocMng = lpBaseMng; lpAllocMng != &AllocMng[2048]; lpAllocMng++) {
if (lpAllocMng->bUse == 0) {
continue;
}
if (lpAllocMng->bFree != 0) {
continue;
}
if (lpAllocMng->addr != (int)lpMem) {
continue;
}
for(lpAllocMng = lpBaseMng; lpAllocMng != &AllocMng[2048]; lpAllocMng++) {
if (lpAllocMng->bUse == 0) { continue; }
if (lpAllocMng->bFree != 0) { continue; }
if (lpAllocMng->addr != (int)lpMem) { continue; }
FreeSize = lpAllocMng->size; FreeSize = lpAllocMng->size;
lpLinkMng = lpAllocMng->prev; lpLinkMng = lpAllocMng->prev;
while ((!!lpLinkMng && (lpLinkMng->bFree != 0))) { while ((!!lpLinkMng && (lpLinkMng->bFree != 0))) {
EndAddr = lpAllocMng->addr + lpAllocMng->size; EndAddr = lpAllocMng->addr + lpAllocMng->size;
lpAllocMng->addr = lpLinkMng->addrB; lpAllocMng->addr = lpLinkMng->addrB;
lpAllocMng->addrB = lpAllocMng->addr; lpAllocMng->addrB = lpAllocMng->addr;
lpAllocMng->size = EndAddr - lpAllocMng->addr; lpAllocMng->size = EndAddr - lpAllocMng->addr;
lpAllocMng->prev = (allocmng *)lpLinkMng->prev; lpAllocMng->prev = (allocmng *)lpLinkMng->prev;
if (lpAllocMng->prev) { lpAllocMng->prev->next = lpAllocMng; } if (lpAllocMng->prev) {
lpAllocMng->prev->next = lpAllocMng;
}
lpLinkMng->bUse = 0; lpLinkMng->bUse = 0;
lpLinkMng->bFree = 0; lpLinkMng->bFree = 0;
lpLinkMng->next = (allocmng *)0x0; lpLinkMng->next = (allocmng *)0x0;
lpLinkMng->prev = (allocmng *)0x0; lpLinkMng->prev = (allocmng *)0x0;
lpLinkMng = lpAllocMng->prev; lpLinkMng = lpAllocMng->prev;
} }
@@ -505,37 +297,32 @@ static u_int FreeMemory(void * lpMem /* r2 */)
lpAllocMng->size = EndAddr - lpAllocMng->addrB; lpAllocMng->size = EndAddr - lpAllocMng->addrB;
lpAllocMng->addr = lpAllocMng->addrB; lpAllocMng->addr = lpAllocMng->addrB;
lpAllocMng->next = (allocmng *)lpLinkMng->next; lpAllocMng->next = (allocmng *)lpLinkMng->next;
if (lpAllocMng->next) { lpAllocMng->next->prev = lpAllocMng; }
if (lpAllocMng->next) {
lpAllocMng->next->prev = lpAllocMng;
}
lpLinkMng->bUse = 0; lpLinkMng->bUse = 0;
lpLinkMng->bFree = 0; lpLinkMng->bFree = 0;
lpLinkMng->next = (allocmng *)0x0; lpLinkMng->next = (allocmng *)0x0;
lpLinkMng->prev = (allocmng *)0x0; lpLinkMng = lpAllocMng->next; lpLinkMng->prev = (allocmng *)0x0;
lpLinkMng = lpAllocMng->next;
} }
if (lpLinkMng == lpBaseMng) { if (lpLinkMng == lpBaseMng) {
lpBaseMng->size = lpBaseMng->addr - lpAllocMng->addrB + lpBaseMng->size; lpBaseMng->size = lpBaseMng->addr - lpAllocMng->addrB + lpBaseMng->size;
lpBaseMng->addr = lpAllocMng->addrB; lpBaseMng->addr = lpAllocMng->addrB;
lpBaseMng->addrB = lpBaseMng->addr; lpBaseMng->addrB = lpBaseMng->addr;
if (lpAllocMng->prev) { lpAllocMng->prev->next = lpBaseMng; } if (lpAllocMng->prev) {
lpAllocMng->prev->next = lpBaseMng;
}
lpBaseMng->prev = lpAllocMng->prev; lpBaseMng->prev = lpAllocMng->prev;
lpAllocMng->bUse = 0; lpAllocMng->bUse = 0;
lpAllocMng->bFree = 0; lpAllocMng->bFree = 0;
lpAllocMng->next = 0; lpAllocMng->next = 0;
lpAllocMng->prev = 0; lpAllocMng->prev = 0;
} else { } else {
lpAllocMng->bFree = 1; lpAllocMng->bFree = 1;
} }
return FreeSize; return FreeSize;