Ejemplo n.º 1
0
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;
}
Ejemplo n.º 2
0
/* 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;
}
Ejemplo n.º 3
0
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;
}
Ejemplo n.º 4
0
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;
}
Ejemplo n.º 5
0
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;
}
Ejemplo n.º 6
0
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;
}
Ejemplo n.º 7
0
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;
}
Ejemplo n.º 8
0
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);
}
Ejemplo n.º 9
0
extern "C" void* __wrap_realloc(void* ptr, size_t size)
{
    breakOnHeapOpFromInterruptHandler();
    return __real_realloc(ptr, size);
}
Ejemplo n.º 10
0
void *__wrap_realloc(void *ptr, size_t size){
  return __real_realloc(ptr,size);
}
Ejemplo n.º 11
0
void *MEM1_realloc(void *p, unsigned int s)
{
	return __real_realloc(p, s);
}
Ejemplo n.º 12
0
void * __wrap_realloc (void* p, size_t size) {
    void *lptr = __real_realloc(p, size);
    TNT_MAKE_MEM_TAINTED(&lptr, sizeof(lptr));
    return lptr;
}