static void
_memory_deallocate_malloc(void* p) {
#if FOUNDATION_SIZE_POINTER == 4
if (!p)
return;
# if BUILD_ENABLE_MEMORY_GUARD
p = _memory_guard_verify(p);
# endif
# if FOUNDATION_PLATFORM_WINDOWS
_aligned_free(p);
# else
free(*((void**)p - 1));
# endif
#else
uintptr_t raw_ptr;
if (!p)
return;
# if BUILD_ENABLE_MEMORY_GUARD
p = _memory_guard_verify(p);
# endif
raw_ptr = *((uintptr_t*)p - 1);
if (raw_ptr & 1) {
raw_ptr &= ~(uintptr_t)1;
# if FOUNDATION_PLATFORM_WINDOWS
if (VirtualFree((void*)raw_ptr, 0, MEM_RELEASE) == 0)
log_warnf(HASH_MEMORY, WARNING_SYSTEM_CALL_FAIL,
STRING_CONST("Failed to VirtualFree 0x%" PRIfixPTR),
(uintptr_t)raw_ptr);
# else
uintptr_t raw_size = *((uintptr_t*)p - 2);
if (munmap((void*)raw_ptr, raw_size) < 0)
log_warnf(HASH_MEMORY, WARNING_SYSTEM_CALL_FAIL,
STRING_CONST("Failed to munmap 0x%" PRIfixPTR " size %" PRIsize),
(uintptr_t)raw_ptr, raw_size);
# endif
}
else {
# if FOUNDATION_PLATFORM_WINDOWS
_aligned_free((void*)raw_ptr);
# else
free((void*)raw_ptr);
# endif
}
#endif
}
static void _memory_deallocate_malloc( void* p )
{
#if FOUNDATION_SIZE_POINTER == 4
if( !p )
return;
# if BUILD_ENABLE_MEMORY_GUARD
p = _memory_guard_verify( p );
# endif
# if FOUNDATION_PLATFORM_WINDOWS
_aligned_free( p );
# else
free( *( (void**)p - 1 ) );
# endif
#else
uintptr_t raw_ptr;
if( !p )
return;
# if BUILD_ENABLE_MEMORY_GUARD
p = _memory_guard_verify( p );
# endif
raw_ptr = *( (uintptr_t*)p - 1 );
if( raw_ptr & 1 )
{
# if FOUNDATION_PLATFORM_WINDOWS
VirtualFree( (void*)raw_ptr, 0, MEM_RELEASE );
# else
uintptr_t raw_size = *( (uintptr_t*)p - 2 );
munmap( (void*)raw_ptr, raw_size );
# endif
}
else
{
# if FOUNDATION_PLATFORM_WINDOWS
_aligned_free( (void*)raw_ptr );
# else
free( (void*)raw_ptr );
# endif
}
#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
}
