static void* _memory_reallocate_malloc( void* p, uint64_t size, unsigned int align )
{
align = _memory_get_align( align );
#if FOUNDATION_PLATFORM_WINDOWS
return _aligned_realloc( p, (size_t)size, align );
#else
if( align )
{
//No realloc aligned available
void* memory = aligned_alloc( align, (size_t)size );
if( !memory )
{
log_panicf( ERROR_OUT_OF_MEMORY, "Unable to reallocate memory: %s", system_error_message( 0 ) );
return 0;
}
if( p )
{
size_t prev_size = malloc_usable_size( p );
memcpy( memory, p, ( size < prev_size ) ? size : prev_size );
}
return memory;
}
return realloc( p, (size_t)size );
#endif
}
static FOUNDATION_NOINLINE void*
lua_allocator(void* env, void* block, size_t osize, size_t nsize) {
if (!nsize && osize) {
memory_deallocate(block);
}
else if (nsize) {
if (!block)
block = memory_allocate(HASH_LUA, nsize, 0, MEMORY_PERSISTENT | MEMORY_32BIT_ADDRESS);
else
block = memory_reallocate(block, nsize, 0, osize);
if (block == 0 && env && ((lua_t*)env)->state)
log_panicf(HASH_LUA, ERROR_OUT_OF_MEMORY, STRING_CONST("Unable to allocate Lua memory (%u bytes)"),
nsize);
}
return block;
}
static void* _memory_allocate_malloc( uint16_t context, uint64_t size, unsigned int align, memory_hint_t hint )
{
align = _memory_get_align( align );
#if FOUNDATION_PLATFORM_WINDOWS
return _aligned_malloc( (size_t)size, align );
#elif FOUNDATION_PLATFORM_POSIX && !FOUNDATION_PLATFORM_ANDROID
void* memory = 0;
if( !align )
return malloc( (size_t)size );
/*int result = posix_memalign( &memory, align, (size_t)size );
if( result || !memory )
log_panicf( ERROR_OUT_OF_MEMORY, "Unable to allocate memory: %s", system_error_message( 0 ) );
return ( result == 0 ) ? memory : 0;*/
memory = aligned_alloc( align, (size_t)size );
if( !memory )
log_panicf( ERROR_OUT_OF_MEMORY, "Unable to allocate memory: %s", system_error_message( 0 ) );
return memory;
#else
void* memory = malloc( size + align );
memory = _memory_align_pointer( memory, align );
return memory;
#endif
}
static void*
_memory_reallocate_malloc(void* p, size_t size, unsigned int align, size_t oldsize) {
#if ( FOUNDATION_SIZE_POINTER == 4 ) && FOUNDATION_PLATFORM_WINDOWS
FOUNDATION_UNUSED(oldsize);
align = _memory_get_align(align);
# if BUILD_ENABLE_MEMORY_GUARD
if (p) {
p = _memory_guard_verify(p);
p = _aligned_realloc(p, (size_t)size + FOUNDATION_MAX_ALIGN * 3, align);
}
else {
p = _aligned_malloc((size_t)size + FOUNDATION_MAX_ALIGN * 3, align);
}
if (p)
p = _memory_guard_initialize(p, (size_t)size);
return p;
# else
return _aligned_realloc(p, (size_t)size, align);
# endif
#else
void* memory;
void* raw_p;
align = _memory_get_align(align);
memory = p;
# if BUILD_ENABLE_MEMORY_GUARD
if (memory)
memory = _memory_guard_verify(memory);
# endif
raw_p = memory ? *((void**)memory - 1) : nullptr;
memory = nullptr;
#if FOUNDATION_PLATFORM_WINDOWS
if (raw_p && !((uintptr_t)raw_p & 1)) {
size_t padding = (align > FOUNDATION_SIZE_POINTER ? align : FOUNDATION_SIZE_POINTER);
# if BUILD_ENABLE_MEMORY_GUARD
size_t extra_padding = FOUNDATION_MAX_ALIGN * 3;
# else
size_t extra_padding = 0;
# endif
void* raw_memory = _aligned_realloc(raw_p, size + padding + extra_padding, align ? align : 8);
if (raw_memory) {
memory = pointer_offset(raw_memory, padding);
*((void**)memory - 1) = raw_memory;
# if BUILD_ENABLE_MEMORY_GUARD
memory = _memory_guard_initialize(memory, size);
# endif
}
}
else {
# if FOUNDATION_SIZE_POINTER == 4
memory = _memory_allocate_malloc_raw(size, align, 0U);
# else
memory = _memory_allocate_malloc_raw(size, align,
(raw_p && ((uintptr_t)raw_p < 0xFFFFFFFFULL)) ?
MEMORY_32BIT_ADDRESS : 0U);
# endif
if (p && memory && oldsize)
memcpy(memory, p, (size < oldsize) ? size : oldsize);
_memory_deallocate_malloc(p);
}
#else //!FOUNDATION_PLATFORM_WINDOWS
//If we're on ARM the realloc can return a 16-bit aligned address, causing raw pointer store to SIGILL
//Realigning does not work since the realloc memory copy preserve cannot be done properly. Revert to normal alloc-and-copy
//Same with alignment, since we cannot guarantee that the returned memory block offset from start of actual memory block
//is the same in the reallocated block as the original block, we need to alloc-and-copy to get alignment
//Memory guard introduces implicit alignments as well so alloc-and-copy for that
#if !FOUNDATION_ARCH_ARM && !FOUNDATION_ARCH_ARM_64 && !BUILD_ENABLE_MEMORY_GUARD
if (!align && raw_p && !((uintptr_t)raw_p & 1)) {
void* raw_memory = realloc(raw_p, (size_t)size + FOUNDATION_SIZE_POINTER);
if (raw_memory) {
*(void**)raw_memory = raw_memory;
memory = pointer_offset(raw_memory, FOUNDATION_SIZE_POINTER);
}
}
else
#endif
{
# if FOUNDATION_SIZE_POINTER == 4
# if !BUILD_ENABLE_LOG
FOUNDATION_UNUSED(raw_p);
# endif
memory = _memory_allocate_malloc_raw(size, align, 0U);
# else
memory = _memory_allocate_malloc_raw(size, align,
(raw_p && ((uintptr_t)raw_p < 0xFFFFFFFFULL)) ?
MEMORY_32BIT_ADDRESS : 0U);
# endif
if (p && memory && oldsize)
memcpy(memory, p, (size < oldsize) ? (size_t)size : (size_t)oldsize);
_memory_deallocate_malloc(p);
}
#endif
if (!memory) {
string_const_t errmsg = system_error_message(0);
log_panicf(HASH_MEMORY, ERROR_OUT_OF_MEMORY,
STRING_CONST("Unable to reallocate memory (%" PRIsize " -> %" PRIsize " @ 0x%" PRIfixPTR ", raw 0x%" PRIfixPTR "): %.*s"),
oldsize, size, (uintptr_t)p, (uintptr_t)raw_p, STRING_FORMAT(errmsg));
}
return memory;
#endif
}
