Compare commits

...

1 Commits

Author SHA1 Message Date
coah
fa7c032980 Match MSL allocator 2026-09-22 04:14:56 +00:00
2 changed files with 681 additions and 209 deletions

View File

@@ -1940,7 +1940,7 @@ config.libs = [
),
# MSL Library
MSLLib("MSL_C.PPCEABI.bare.H", [
Object(NonMatching, "MSL_Common/alloc.c"),
Object(Matching, "MSL_Common/alloc.c"),
Object(Matching, "MSL_Common/errno.c"),
Object(Matching, "MSL_Common/ansi_files.c"),
Object(NonMatching, "MSL_Common_Embedded/ansi_fp.c"),

View File

@@ -3,144 +3,151 @@
#pragma exceptions on
extern void __sys_free(void* ptr);
typedef struct Block {
struct Block* prev;
struct Block* next;
unsigned int max_size;
unsigned int size;
} Block;
typedef struct SubBlock {
unsigned int size;
Block* block;
struct SubBlock* prev;
struct SubBlock* next;
} SubBlock;
struct FixSubBlock;
typedef struct FixBlock {
struct FixBlock* prev_;
struct FixBlock* next_;
unsigned int client_size_;
struct FixSubBlock* start_;
unsigned int n_allocated_;
} FixBlock;
typedef struct FixSubBlock {
FixBlock* block_;
struct FixSubBlock* next_;
} FixSubBlock;
typedef struct FixStart {
FixBlock* tail_;
FixBlock* head_;
} FixStart;
typedef struct __mem_pool_obj {
Block* start_;
FixStart fix_start[6];
} __mem_pool_obj;
extern void* __sys_alloc(unsigned int size);
typedef struct __mem_pool {
void* reserved[14];
} __mem_pool;
typedef int tag_word;
typedef struct Block {
struct Block* pPrev;
struct Block* pNext;
unsigned int maxSize;
unsigned int size;
} Block;
typedef struct block_header {
tag_word tag;
struct block_header* prev;
struct block_header* next;
} block_header;
typedef struct SubBlock {
unsigned int size;
Block* pBlock;
struct SubBlock* pPrev;
struct SubBlock* pNext;
} SubBlock;
typedef struct list_header {
block_header* rover;
block_header header;
} list_header;
struct FixSubBlock;
typedef struct heap_header {
struct heap_header* prev;
struct heap_header* next;
} heap_header;
typedef struct FixBlock {
struct FixBlock* pPrev;
struct FixBlock* pNext;
unsigned int clientSize;
struct FixSubBlock* pStart;
unsigned int allocatedSize;
} FixBlock;
struct mem_pool_obj;
typedef void* (*sys_alloc_ptr)(unsigned int, struct mem_pool_obj*);
typedef void (*sys_free_ptr)(void*, struct mem_pool_obj*);
typedef struct FixSubBlock {
FixBlock* pBlock;
struct FixSubBlock* pNext;
} FixSubBlock;
typedef struct pool_options {
sys_alloc_ptr sys_alloc_func;
sys_free_ptr sys_free_func;
unsigned int min_heap_size;
int always_search_first;
} pool_options;
typedef struct FixStart {
FixBlock* pTail;
FixBlock* pHead;
} FixStart;
typedef struct mem_pool_obj {
list_header free_list;
pool_options options;
heap_header* heap_list;
void* userData;
} mem_pool_obj;
mem_pool_obj __malloc_pool;
static int initialized = 0;
typedef struct __mem_pool_obj {
Block* pStart;
FixStart fixStart[6];
} __mem_pool_obj;
static SubBlock* SubBlock_merge_prev(SubBlock*, SubBlock**);
static void SubBlock_merge_next(SubBlock*, SubBlock**);
static SubBlock* Block_subBlock(Block*, unsigned int, unsigned int*);
static void* allocate_from_var_pools(__mem_pool_obj*, unsigned int, unsigned int*);
static void* soft_allocate_from_var_pools(__mem_pool_obj*, unsigned int, unsigned int*);
static void FixBlock_construct(FixBlock*, FixBlock*, FixBlock*, unsigned int, void*, unsigned int);
static void* allocate_from_fixed_pools(__mem_pool_obj*, unsigned int, unsigned int*);
static unsigned int __pool_allocate_resize(__mem_pool_obj*, void*, unsigned int, unsigned int*);
static const unsigned int fix_pool_sizes[] = {4, 12, 20, 36, 52, 68};
const unsigned int fix_pool_sizes[] = {4, 12, 20, 36, 52, 68};
#define SubBlock_size(ths) ((ths)->size & 0xFFFFFFF8)
#define SubBlock_block(ths) ((Block*)((unsigned int)((ths)->block) & ~0x1))
#define SubBlock_block(ths) ((Block*)((unsigned int)((ths)->pBlock) & ~0x1))
#define Block_size(ths) ((ths)->size & 0xFFFFFFF8)
#define Block_start(ths) (*(SubBlock**)((char*)(ths) + Block_size((ths)) - sizeof(unsigned int)))
#define SubBlock_set_free(ths) \
unsigned int this_size = SubBlock_size((ths)); \
(ths)->size &= ~0x2; \
*(unsigned int*)((char*)(ths) + this_size) &= ~0x4; \
((SubBlock*)((char*)(ths) + this_size))->size &= ~0x4; \
*(unsigned int*)((char*)(ths) + this_size - sizeof(unsigned int)) = this_size
#define SubBlock_is_free(ths) !((ths)->size & 2)
#define SubBlock_set_size(ths, sz) \
(ths)->size &= ~0xFFFFFFF8; \
(ths)->size |= (sz) & 0xFFFFFFF8; \
if (SubBlock_is_free((ths))) \
*(unsigned int*)((char*)(ths) + (sz) - sizeof(unsigned int)) = (sz)
if (SubBlock_is_free((ths))) { \
*(unsigned int*)((char*)(ths) + (sz) - sizeof(unsigned int)) = (sz); \
}
#define SubBlock_from_pointer(ptr) ((SubBlock*)((char*)(ptr) - 8))
#define FixSubBlock_from_pointer(ptr) ((FixSubBlock*)((char*)(ptr) - 4))
#define FixBlock_client_size(ths) ((ths)->client_size_)
#define FixSubBlock_size(ths) (FixBlock_client_size((ths)->block_))
#define FixBlock_client_size(ths) ((ths)->clientSize)
#define FixSubBlock_size(ths) (FixBlock_client_size((ths)->pBlock))
#define classify(ptr) (*(unsigned int*)((char*)(ptr) - sizeof(unsigned int)) & 1)
#define classify(ptr) ((unsigned int)FixSubBlock_from_pointer(ptr)->pBlock & 1)
#define __msize_inline(ptr) (!classify(ptr) ? FixSubBlock_size(FixSubBlock_from_pointer(ptr)) : SubBlock_size(SubBlock_from_pointer(ptr)) - 8)
#define Block_empty(ths) (_sb = (SubBlock*)((char*)(ths) + 16)), SubBlock_is_free(_sb) && SubBlock_size(_sb) == Block_size((ths)) - 24
#define Block_empty(ths) (_sb = (SubBlock*)(ths + 1)), SubBlock_is_free(_sb) && SubBlock_size(_sb) == Block_size((ths)) - 24
void Block_link(Block* ths, SubBlock* sb) {
SubBlock** st;
SubBlock_set_free(sb);
st = &Block_start(ths);
void Block_link(Block*, SubBlock*);
void deallocate_from_fixed_pools(__mem_pool_obj*, void*, unsigned int);
void* malloc(unsigned int);
void* calloc(unsigned int, unsigned int);
void* realloc(void*, unsigned int);
void free(void*);
if (*st != 0) {
sb->prev = (*st)->prev;
sb->prev->next = sb;
sb->next = *st;
(*st)->prev = sb;
*st = sb;
*st = SubBlock_merge_prev(*st, st);
SubBlock_merge_next(*st, st);
} else {
*st = sb;
sb->prev = sb;
sb->next = sb;
static void SubBlock_construct(SubBlock* ths, unsigned int size, Block* bp, int prev_alloc, int this_alloc) {
ths->pBlock = (Block*)((unsigned int)bp | 1);
ths->size = size;
if (prev_alloc) {
ths->size |= 4;
}
if (this_alloc) {
ths->size |= 2;
((SubBlock*)((char*)ths + size))->size |= 4;
} else {
*(unsigned int*)((char*)ths + size - sizeof(unsigned int)) = size;
}
}
static SubBlock* SubBlock_split(SubBlock* ths, unsigned int sz) {
unsigned int origsize;
int isfree;
int isprevalloc;
SubBlock* np;
Block* bp;
origsize = SubBlock_size(ths);
isfree = SubBlock_is_free(ths);
isprevalloc = (int)(ths->size & 4);
np = (SubBlock*)((char*)ths + sz);
bp = SubBlock_block(ths);
SubBlock_construct(ths, sz, bp, isprevalloc, !isfree);
SubBlock_construct(np, origsize - sz, bp, !isfree, !isfree);
if (isfree) {
np->pNext = ths->pNext;
np->pNext->pPrev = np;
np->pPrev = ths;
ths->pNext = np;
}
return np;
}
static void Block_unlink(Block* ths, SubBlock* sb) {
SubBlock** st;
unsigned int this_size = SubBlock_size(sb);
sb->size |= 2;
((SubBlock*)((char*)sb + this_size))->size |= 4;
st = &Block_start(ths);
if (*st == sb) {
*st = sb->pNext;
}
if (*st == sb) {
*st = NULL;
ths->maxSize = 0;
} else {
sb->pNext->pPrev = sb->pPrev;
sb->pPrev->pNext = sb->pNext;
}
if (ths->max_size < SubBlock_size(*st))
ths->max_size = SubBlock_size(*st);
}
static SubBlock* SubBlock_merge_prev(SubBlock* ths, SubBlock** start) {
@@ -149,72 +156,39 @@ static SubBlock* SubBlock_merge_prev(SubBlock* ths, SubBlock** start) {
if (!(ths->size & 0x04)) {
prevsz = *(unsigned int*)((char*)ths - sizeof(unsigned int));
if (prevsz & 0x2)
if (prevsz & 0x2) {
return ths;
}
p = (SubBlock*)((char*)ths - prevsz);
SubBlock_set_size(p, prevsz + SubBlock_size(ths));
if (*start == ths)
*start = (*start)->next;
ths->next->prev = ths->prev;
ths->next->prev->next = ths->next;
if (*start == ths) {
*start = (*start)->pNext;
}
ths->pNext->pPrev = ths->pPrev;
ths->pNext->pPrev->pNext = ths->pNext;
return p;
}
return ths;
}
static void SubBlock_merge_next(SubBlock* pBlock, SubBlock** pStart) {
SubBlock* next_sub_block;
unsigned int this_cur_size;
next_sub_block = (SubBlock*)((char*)pBlock + (pBlock->size & 0xFFFFFFF8));
if (!(next_sub_block->size & 2)) {
this_cur_size = (pBlock->size & 0xFFFFFFF8) + (next_sub_block->size & 0xFFFFFFF8);
pBlock->size &= ~0xFFFFFFF8;
pBlock->size |= this_cur_size & 0xFFFFFFF8;
if (!(pBlock->size & 2)) {
*(unsigned int*)((char*)(pBlock) + (this_cur_size)-4) = (this_cur_size);
}
if (!(pBlock->size & 2)) {
*(unsigned int*)((char*)pBlock + this_cur_size) &= ~4;
} else {
*(unsigned int*)((char*)pBlock + this_cur_size) |= 4;
}
if (*pStart == next_sub_block) {
*pStart = (*pStart)->next;
}
if (*pStart == next_sub_block) {
*pStart = 0;
}
next_sub_block->next->prev = next_sub_block->prev;
next_sub_block->prev->next = next_sub_block->next;
}
}
static Block* __unlink(__mem_pool_obj* pool_obj, Block* bp) {
Block* result = bp->next;
Block* result = bp->pNext;
if (result == bp) {
result = 0;
result = NULL;
}
if (pool_obj->start_ == bp) {
pool_obj->start_ = result;
if (pool_obj->pStart == bp) {
pool_obj->pStart = result;
}
if (result != 0) {
result->prev = bp->prev;
result->prev->next = result;
if (result != NULL) {
result->pPrev = bp->pPrev;
result->pPrev->pNext = result;
}
bp->next = 0;
bp->prev = 0;
bp->pNext = NULL;
bp->pPrev = NULL;
return result;
}
@@ -231,12 +205,13 @@ static void deallocate_from_var_pools(__mem_pool_obj* pool_obj, void* ptr) {
}
}
void __init_pool_obj(__mem_pool* pool_obj) {
static void __init_pool_obj(__mem_pool* pool_obj) {
memset(pool_obj, 0, sizeof(__mem_pool_obj));
}
__mem_pool protopool;
static __mem_pool* get_malloc_pool() {
static __mem_pool protopool;
static unsigned char init = 0;
if (!init) {
__init_pool_obj(&protopool);
@@ -246,67 +221,11 @@ static __mem_pool* get_malloc_pool() {
return &protopool;
}
void deallocate_from_fixed_pools(__mem_pool_obj* pool_obj, void* ptr, unsigned int size) {
unsigned int i = 0;
FixSubBlock* p;
FixBlock* b;
FixStart* fs;
while (size > fix_pool_sizes[i]) {
++i;
}
fs = &pool_obj->fix_start[i];
p = FixSubBlock_from_pointer(ptr);
b = p->block_;
if (b->start_ == 0 && fs->head_ != b) {
if (fs->tail_ == b) {
fs->head_ = fs->head_->prev_;
fs->tail_ = fs->tail_->prev_;
} else {
b->prev_->next_ = b->next_;
b->next_->prev_ = b->prev_;
b->next_ = fs->head_;
b->prev_ = b->next_->prev_;
b->prev_->next_ = b;
b->next_->prev_ = b;
fs->head_ = b;
}
}
p->next_ = b->start_;
b->start_ = p;
if (--b->n_allocated_ == 0) {
if (fs->head_ == b) {
fs->head_ = b->next_;
}
if (fs->tail_ == b) {
fs->tail_ = b->prev_;
}
b->prev_->next_ = b->next_;
b->next_->prev_ = b->prev_;
if (fs->head_ == b) {
fs->head_ = 0;
}
if (fs->tail_ == b) {
fs->tail_ = 0;
}
deallocate_from_var_pools(pool_obj, b);
}
}
void __pool_free(__mem_pool* pool, void* ptr) {
static void __pool_free(__mem_pool* pool, void* ptr) {
__mem_pool_obj* pool_obj;
unsigned int size;
if (ptr == 0) {
if (ptr == NULL) {
return;
}
@@ -320,6 +239,559 @@ void __pool_free(__mem_pool* pool, void* ptr) {
}
}
static void link(__mem_pool_obj* pool, Block* bp) {
if (pool->pStart != NULL) {
bp->pPrev = pool->pStart->pPrev;
bp->pPrev->pNext = bp;
bp->pNext = pool->pStart;
pool->pStart->pPrev = bp;
pool->pStart = bp;
} else {
pool->pStart = bp;
bp->pPrev = bp;
bp->pNext = bp;
}
}
static void Block_construct(Block* ths, unsigned int size) {
SubBlock* sb;
ths->size = size | 3;
((SubBlock*)((char*)ths + size - 8))->size = ths->size;
sb = (SubBlock*)(ths + 1);
sb->pBlock = (Block*)((unsigned int)ths | 1);
sb->size = size - 0x18;
*(unsigned int*)((char*)sb + (size - 0x18) - sizeof(unsigned int)) = size - 0x18;
ths->maxSize = size - 0x18;
Block_start(ths) = NULL;
Block_link(ths, sb);
}
static Block* link_new_block(__mem_pool_obj* pool, unsigned int size) {
Block* bp;
size = (size + 31) & ~7;
if (size < 0x10000) {
size = 0x10000;
}
bp = (Block*)__sys_alloc(size);
if (bp == NULL) {
return NULL;
}
Block_construct(bp, size);
link(pool, bp);
return bp;
}
static SubBlock* Block_subBlock(Block* bp, unsigned int size, unsigned int* out) {
SubBlock* st;
SubBlock* sb;
unsigned int sb_size;
unsigned int max_found;
st = Block_start(bp);
if (st == NULL) {
bp->maxSize = 0;
return NULL;
}
sb = st;
sb_size = SubBlock_size(sb);
max_found = sb_size;
while (sb_size < size) {
sb = sb->pNext;
sb_size = SubBlock_size(sb);
if (max_found < sb_size) {
max_found = sb_size;
}
if (sb == st) {
bp->maxSize = max_found;
if (out != NULL) {
*out = max_found - 8;
}
return NULL;
}
}
if (sb_size - size >= 0x50) {
SubBlock_split(sb, size);
}
Block_start(bp) = sb->pNext;
Block_unlink(bp, sb);
if (out != NULL) {
*out = SubBlock_size(sb) - 8;
}
return sb;
}
static void Block_link(Block* ths, SubBlock* sb) {
SubBlock** st;
SubBlock_set_free(sb);
st = &Block_start(ths);
if (*st != NULL) {
sb->pPrev = (*st)->pPrev;
sb->pPrev->pNext = sb;
sb->pNext = *st;
(*st)->pPrev = sb;
*st = sb;
*st = SubBlock_merge_prev(*st, st);
SubBlock_merge_next(*st, st);
} else {
*st = sb;
sb->pPrev = sb;
sb->pNext = sb;
}
if (ths->maxSize < SubBlock_size(*st)) {
ths->maxSize = SubBlock_size(*st);
}
}
static void SubBlock_merge_next(SubBlock* pBlock, SubBlock** pStart) {
SubBlock* next_sub_block;
unsigned int this_cur_size;
next_sub_block = (SubBlock*)((char*)pBlock + (pBlock->size & 0xFFFFFFF8));
if (!(next_sub_block->size & 2)) {
this_cur_size = (pBlock->size & 0xFFFFFFF8) + (next_sub_block->size & 0xFFFFFFF8);
pBlock->size &= ~0xFFFFFFF8;
pBlock->size |= this_cur_size & 0xFFFFFFF8;
if (!(pBlock->size & 2)) {
*(unsigned int*)((char*)pBlock + this_cur_size - sizeof(unsigned int)) = this_cur_size;
}
if (!(pBlock->size & 2)) {
((SubBlock*)((char*)pBlock + this_cur_size))->size &= ~4;
} else {
((SubBlock*)((char*)pBlock + this_cur_size))->size |= 4;
}
if (*pStart == next_sub_block) {
*pStart = (*pStart)->pNext;
}
if (*pStart == next_sub_block) {
*pStart = NULL;
}
next_sub_block->pNext->pPrev = next_sub_block->pPrev;
next_sub_block->pPrev->pNext = next_sub_block->pNext;
}
}
static void* allocate_from_var_pools(__mem_pool_obj* pool, unsigned int size, unsigned int* out) {
Block* bp;
SubBlock* ptr;
if (out != NULL) {
*out = 0;
}
size = (size + 15) & ~7;
if (size < 0x50) {
size = 0x50;
}
bp = pool->pStart != NULL ? pool->pStart : link_new_block(pool, size);
if (bp == NULL) {
return NULL;
}
do {
if (size <= bp->maxSize) {
ptr = Block_subBlock(bp, size, out);
if (ptr != NULL) {
pool->pStart = bp;
break;
}
}
bp = bp->pNext;
if (bp == pool->pStart) {
bp = link_new_block(pool, size);
if (bp == NULL) {
return NULL;
}
ptr = Block_subBlock(bp, size, out);
break;
}
} while (1);
return (char*)ptr + 8;
}
static void* soft_allocate_from_var_pools(__mem_pool_obj* pool, unsigned int size, unsigned int* out) {
register Block* bp;
register SubBlock* ptr;
size = (size + 15) & ~7;
if (size < 0x50) {
size = 0x50;
}
*out = 0;
bp = pool->pStart;
if (bp == NULL) {
return NULL;
}
do {
if (size <= bp->maxSize) {
ptr = Block_subBlock(bp, size, NULL);
if (ptr != NULL) {
pool->pStart = bp;
break;
}
}
if (bp->maxSize > 8 && *out < bp->maxSize - 8) {
*out = bp->maxSize - 8;
}
bp = bp->pNext;
if (bp == pool->pStart) {
return NULL;
}
} while (1);
return (char*)ptr + 8;
}
static void FixBlock_construct(FixBlock* this, FixBlock* prev, FixBlock* next, unsigned int poolIdx, void* start, unsigned int totalSize) {
unsigned int fixSubBlockSize;
unsigned int n;
char* p;
unsigned int i;
char* np;
this->pPrev = prev;
this->pNext = next;
prev->pNext = this;
next->pPrev = this;
this->clientSize = fix_pool_sizes[poolIdx];
fixSubBlockSize = fix_pool_sizes[poolIdx] + 4;
n = totalSize / fixSubBlockSize;
p = (char*)start;
for (i = 0; i < n - 1; ++i) {
np = p + fixSubBlockSize;
((FixSubBlock*)p)->pBlock = this;
((FixSubBlock*)p)->pNext = (FixSubBlock*)np;
p = np;
}
((FixSubBlock*)p)->pBlock = this;
((FixSubBlock*)p)->pNext = NULL;
this->pStart = (FixSubBlock*)start;
this->allocatedSize = 0;
}
static void* allocate_from_fixed_pools(__mem_pool_obj* pool, unsigned int size, unsigned int* out) {
unsigned int i = 0;
FixSubBlock* p;
FixStart* fs;
while (size > fix_pool_sizes[i]) {
++i;
}
fs = &pool->fixStart[i];
if (fs->pHead == NULL || fs->pHead->pStart == NULL) {
unsigned int size_requested = 0x1000;
char* newblock;
unsigned int size_received;
unsigned int n, nsave, size_has;
n = (size_requested - sizeof(FixBlock)) / (fix_pool_sizes[i] + 4);
if (n > 0x100) {
n = 0x100;
}
nsave = n;
while (n >= 10) {
size_requested = n * (fix_pool_sizes[i] + 4) + sizeof(FixBlock);
newblock = (char*)soft_allocate_from_var_pools(pool, size_requested, &size_has);
if (newblock != NULL) {
break;
}
if (size_has > sizeof(FixBlock)) {
n = (size_has - sizeof(FixBlock)) / (fix_pool_sizes[i] + 4);
} else {
n = 0;
}
}
if (newblock == NULL) {
unsigned int cr_backup;
n = nsave;
while (1) {
size_requested = n * (fix_pool_sizes[i] + 4) + sizeof(FixBlock);
newblock = (char*)allocate_from_var_pools(pool, size_requested, &cr_backup);
if (newblock != NULL) {
break;
}
n = cr_backup / (fix_pool_sizes[i] + sizeof(FixBlock) + 4);
if (n < 10) {
if (out != NULL) {
*out = 0;
}
return NULL;
}
}
}
size_received = __msize_inline(newblock);
if (fs->pHead == NULL) {
fs->pHead = (FixBlock*)newblock;
fs->pTail = (FixBlock*)newblock;
}
FixBlock_construct((FixBlock*)newblock, fs->pTail, fs->pHead, i, (FixSubBlock*)((FixBlock*)newblock + 1), size_received - sizeof(FixBlock));
fs->pHead = (FixBlock*)newblock;
}
p = fs->pHead->pStart;
fs->pHead->pStart = p->pNext;
++fs->pHead->allocatedSize;
if (fs->pHead->pStart == NULL) {
fs->pHead = fs->pHead->pNext;
fs->pTail = fs->pTail->pNext;
}
if (out != NULL) {
*out = fix_pool_sizes[i];
}
return (char*)p + 4;
}
void deallocate_from_fixed_pools(__mem_pool_obj* pool_obj, void* ptr, unsigned int size) {
unsigned int i = 0;
FixSubBlock* p;
FixBlock* b;
FixStart* fs;
while (size > fix_pool_sizes[i]) {
++i;
}
fs = &pool_obj->fixStart[i];
p = FixSubBlock_from_pointer(ptr);
b = p->pBlock;
if (b->pStart == NULL && fs->pHead != b) {
if (fs->pTail == b) {
fs->pHead = fs->pHead->pPrev;
fs->pTail = fs->pTail->pPrev;
} else {
b->pPrev->pNext = b->pNext;
b->pNext->pPrev = b->pPrev;
b->pNext = fs->pHead;
b->pPrev = b->pNext->pPrev;
b->pPrev->pNext = b;
b->pNext->pPrev = b;
fs->pHead = b;
}
}
p->pNext = b->pStart;
b->pStart = p;
if (--b->allocatedSize == 0) {
if (fs->pHead == b) {
fs->pHead = b->pNext;
}
if (fs->pTail == b) {
fs->pTail = b->pPrev;
}
b->pPrev->pNext = b->pNext;
b->pNext->pPrev = b->pPrev;
if (fs->pHead == b) {
fs->pHead = NULL;
}
if (fs->pTail == b) {
fs->pTail = NULL;
}
deallocate_from_var_pools(pool_obj, b);
}
}
static unsigned int __pool_allocate_resize(__mem_pool_obj* pool, void* ptr, unsigned int size, unsigned int* out) {
unsigned int sz;
unsigned int this_size;
unsigned int orig_size;
SubBlock* sb;
SubBlock* next_sub;
orig_size = __msize_inline(ptr);
if (size == orig_size) {
if (out != NULL) {
*out = orig_size;
}
return 1;
}
if (classify(ptr)) {
if (size > 0xFFFFFF7F) {
size = 0xFFFFFF7F;
}
sz = size + 8;
sz = (sz + 7) & ~7;
if (sz < 0x50) {
sz = 0x50;
}
sb = SubBlock_from_pointer(ptr);
this_size = orig_size + 8;
next_sub = (SubBlock*)((char*)sb + this_size);
if (SubBlock_is_free(next_sub) && sz <= this_size + SubBlock_size(next_sub)) {
SubBlock_merge_next(sb, &Block_start(SubBlock_block(sb)));
this_size = SubBlock_size(sb);
}
if (this_size >= sz + 0x50) {
Block_link(SubBlock_block(sb), SubBlock_split(sb, sz));
this_size = SubBlock_size(sb);
}
this_size -= 8;
if (out != NULL) {
*out = this_size;
}
if (size > orig_size) {
if (out != NULL && size > this_size && SubBlock_is_free(next_sub)) {
*out += SubBlock_size(next_sub);
}
return size <= this_size;
}
return this_size < orig_size;
}
if (out != NULL) {
*out = orig_size;
}
return 0;
}
void* malloc(register unsigned int size) {
void* rv;
register __mem_pool_obj* pool_obj;
if (size == 0) {
goto null_return;
}
pool_obj = (__mem_pool_obj*)get_malloc_pool();
if (size > ~0x30u) {
return NULL;
}
if (size <= 68) {
rv = allocate_from_fixed_pools(pool_obj, size, NULL);
} else {
rv = allocate_from_var_pools(pool_obj, size, NULL);
}
return rv;
null_return:
return NULL;
}
void free(void* ptr) {
__pool_free(get_malloc_pool(), ptr);
}
void* realloc(void* ptr, unsigned int size) {
register unsigned int rv = size;
register __mem_pool_obj* pool;
unsigned int current_size;
unsigned int orig_size;
pool = (__mem_pool_obj*)get_malloc_pool();
if (ptr == NULL) {
if (rv > ~0x30u) {
return NULL;
}
if (rv <= 68) {
return allocate_from_fixed_pools(pool, rv, NULL);
}
return allocate_from_var_pools(pool, rv, NULL);
}
if (rv == 0) {
if (ptr != NULL) {
current_size = __msize_inline(ptr);
if (current_size <= 68) {
deallocate_from_fixed_pools(pool, ptr, current_size);
} else {
deallocate_from_var_pools(pool, ptr);
}
}
return NULL;
}
orig_size = __msize_inline(ptr);
{
unsigned int result = __pool_allocate_resize(pool, ptr, rv, NULL);
if (result || rv <= orig_size) {
return ptr;
}
}
if (rv > ~0x30u) {
rv = 0;
} else if (rv <= 68) {
rv = (unsigned int)allocate_from_fixed_pools(pool, rv, NULL);
} else {
rv = (unsigned int)allocate_from_var_pools(pool, rv, NULL);
}
if (rv != 0) {
memcpy((void*)rv, ptr, orig_size);
if (ptr != NULL) {
unsigned int cur_sz = __msize_inline(ptr);
if (cur_sz <= 68) {
deallocate_from_fixed_pools(pool, ptr, cur_sz);
} else {
deallocate_from_var_pools(pool, ptr);
}
}
}
return (void*)rv;
}
void* calloc(unsigned int nmemb, unsigned int size) {
register void* ptr;
register unsigned int total;
__mem_pool_obj* pool_obj;
pool_obj = (__mem_pool_obj*)get_malloc_pool();
total = size * nmemb;
if (total > ~0x30u) {
ptr = NULL;
} else if (total <= 68) {
ptr = allocate_from_fixed_pools(pool_obj, total, NULL);
} else {
ptr = allocate_from_var_pools(pool_obj, total, NULL);
}
if (ptr != NULL) {
memset(ptr, 0, total);
}
return ptr;
}