void *__wrap_realloc(void *p, size_t size)
{
void *n;
// ptr from mem2
if(((u32)p & 0x10000000) != 0 || (p == 0 && size > MEM2_PRIORITY_SIZE))
{
n = g_mem2gp.reallocate(p, size);
if(n != 0)
return n;
n = __real_malloc(size);
if(n == 0)
return 0;
if(p != 0)
{
memcpy(n, p, MEM2_usableSize(p) < size ? MEM2_usableSize(p) : size);
g_mem2gp.release(p);
}
return n;
}
// ptr from malloc
n = __real_realloc(p, size);
if(n != 0)
return n;
n = g_mem2gp.allocate(size);
if(n == 0)
return 0;
if(p != 0)
{
memcpy(n, p, __real_malloc_usable_size(p) < size ? __real_malloc_usable_size(p) : size);
__real_free(p);
}
return n;
}
/* This function wraps the real realloc */
void *__wrap_realloc (void *ptr, size_t size)
{
void *lptr = __real_realloc(ptr, size);
mem_alloced += size;
printf("realloc: %p, ptr %p, size %zu\n", lptr, ptr, size);
return lptr;
}
void* __wrap_realloc(void* oldptr, size_t size)
{
if (oldptr == nullptr) return malloc(size);
void* p = (char*)oldptr-16;
void* new_p = __real_realloc(p, size);
if (new_p == nullptr) {
#ifdef DEBUG_MALLOC
printf("MALLOC: %p : %lld realloc\n", (char*)oldptr, size);
#endif
return nullptr;
}
size_t old_size = *(size_t*)new_p;
if (old_size > size) {
mem_usage -= old_size;
mem_usage += size;
*(size_t*)new_p = size;
}
#ifdef DEBUG_MALLOC
printf("MALLOC: %p : %lld realloc %lld\n", (char*)oldptr, size, old_size);
#endif
return (char*)new_p + 16;
}
extern "C" void* reallocWithTag(void* ptr, size_t size, unsigned int tag)
{
void* p = __real_realloc(ptr, size + sizeof(tag));
if (!p)
return p;
setTag(p, tag);
return p;
}
void* __wrap_realloc(void *ptr, size_t size) {
void *tmp = __real_realloc(ptr, size);
char error[512];
if (tmp == NULL) {
strerror_r(errno, (char *) &error, sizeof(error));
log_itf(LOG_ERROR, "realloc() failed: (%d) %s", errno, error);
exit(EXIT_FAILURE);
}
return tmp;
}
void *__wrap_realloc(void *ptr, size_t size)
{
void *lptr = __real_realloc(ptr,size);
if ( ptr==NULL ) printf("@ %s:[%p] + %p %#x\n", program_invocation_short_name
, __builtin_return_address(0)
, lptr
, size
);
return lptr;
}
void* __wrap_realloc( void *ptr, size_t size )
{
LockAlloc();
void *new_ptr = __real_realloc( ptr, size );
if( new_ptr == NULL && size != 0 && IsSingleLocked() && g_bMemoryAssert )
{
TempLog( "realloc failed: %p %ubytes\r\n", ptr, size );
MemoryError();
}
UnlockAlloc();
return new_ptr;
}
extern "C" void* wrap(realloc)(void* p, size_t sz)
{
init_lib();
fibjs::MemPool& mp = fibjs::MemPool::global();
if (p == 0)
{
void* p1 = __real_malloc(FULL_SIZE(sz));
if (p1) {
memset(p1, 0, STUB_SIZE);
mp.add(p1, sz);
}
return MEM_PTR(p1);
}
if (sz == 0)
{
void* p1 = STUB_PTR(p);
if (p1)
mp.remove(p1);
__real_free(p1);
return 0;
}
void* p1 = STUB_PTR(p);
mp.remove(p1);
void* p2 = __real_realloc(p1, FULL_SIZE(sz));
if (p2) {
memset(p2, 0, STUB_SIZE);
mp.add(p2, sz);
}
else
mp.add(p1);
return MEM_PTR(p2);
}
extern "C" void* __wrap_realloc(void* ptr, size_t size)
{
breakOnHeapOpFromInterruptHandler();
return __real_realloc(ptr, size);
}
void *__wrap_realloc(void *ptr, size_t size){
return __real_realloc(ptr,size);
}
void *MEM1_realloc(void *p, unsigned int s)
{
return __real_realloc(p, s);
}
void * __wrap_realloc (void* p, size_t size) {
void *lptr = __real_realloc(p, size);
TNT_MAKE_MEM_TAINTED(&lptr, sizeof(lptr));
return lptr;
}
