From eaf55b677c53d76a11d2b860034337afdf8d8817 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stephan=20M=C3=BChlstrasser?= Date: Tue, 20 Oct 2015 13:02:51 +0200 Subject: [PATCH 1/2] Generic aligned malloc implementation. Used for platforms where none of posix_memalign(), memalign() and _aligned_malloc() is available. --- src/lib/openjp2/opj_malloc.c | 80 +++++++++++++++++++++++++++++++++--- 1 file changed, 74 insertions(+), 6 deletions(-) diff --git a/src/lib/openjp2/opj_malloc.c b/src/lib/openjp2/opj_malloc.c index 3bbf80d8..e2ace0b8 100644 --- a/src/lib/openjp2/opj_malloc.c +++ b/src/lib/openjp2/opj_malloc.c @@ -32,6 +32,10 @@ #define OPJ_SKIP_POISON #include "opj_includes.h" +#ifndef SIZE_MAX +#define SIZE_MAX ((size_t) -1) +#endif + static INLINE void *opj_aligned_alloc_n(size_t alignment, size_t size) { void* ptr; @@ -59,8 +63,30 @@ static INLINE void *opj_aligned_alloc_n(size_t alignment, size_t size) #elif defined(HAVE__ALIGNED_MALLOC) ptr = _aligned_malloc(size, alignment); #else -/* TODO: _mm_malloc(x,y) */ -#error missing aligned alloc function + /* + * Generic aligned malloc implementation. + * Uses ptrdiff_t for the integer manipulation of the pointer, as + * uintptr_t is not available in C89. + */ + { + ptrdiff_t mask; + void *mem; + + /* Room for padding and extra pointer stored in front of allocated area */ + size_t overhead = (alignment - 1) + sizeof(void *); + + /* Avoid integer overflow */ + if (size > SIZE_MAX - overhead) + return NULL; + + mem = malloc(size + overhead); + if (!mem) + return mem; + + mask = ~(ptrdiff_t)(alignment - 1); + ptr = (void *) ((ptrdiff_t) (mem + overhead) & mask); + ((void**) ptr)[-1] = mem; + } #endif return ptr; } @@ -97,8 +123,46 @@ static INLINE void *opj_aligned_realloc_n(void *ptr, size_t alignment, size_t ne #elif defined(HAVE__ALIGNED_MALLOC) r_ptr = _aligned_realloc( ptr, new_size, alignment ); #else -/* TODO: _mm_malloc(x,y) */ -#error missing aligned realloc function + { + void *oldmem, *newmem; + size_t overhead = (alignment - 1) + sizeof(void *); + + if (new_size == 0) { + my_aligned_free(ptr); + return NULL; + } + + /* Avoid integer overflow */ + if (new_size > SIZE_MAX - overhead) + return NULL; + + oldmem = ((void**) ptr)[-1]; + newmem = realloc(oldmem, new_size + overhead); + if (!newmem) + return newmem; + + if (newmem == oldmem) { + r_ptr = ptr; + } + else { + ptrdiff_t old_offset, new_offset; + ptrdiff_t mask; + + /* realloc created a new copy, realign the copied memory block */ + old_offset = (char *) ptr - (char *) oldmem; + + mask = ~(ptrdiff_t)(alignment - 1); + r_ptr = (void *) ((ptrdiff_t) (newmem + overhead) & mask); + + new_offset = (char *) r_ptr - (char *) newmem; + + if (new_offset != old_offset) { + memmove((char *) newmem + new_offset, (char *) newmem + old_offset, + new_size); + } + ((void**) r_ptr)[-1] = newmem; + } + } #endif return r_ptr; } @@ -129,10 +193,14 @@ void * opj_aligned_realloc(void *ptr, size_t size) void opj_aligned_free(void* ptr) { -#ifdef HAVE__ALIGNED_MALLOC +#if defined(HAVE_POSIX_MEMALIGN) || defined(HAVE_MEMALIGN) + free( ptr ); +#elif defined(HAVE__ALIGNED_MALLOC) _aligned_free( ptr ); #else - free( ptr ); + /* Generic implementation has malloced pointer stored in front of used area */ + if (ptr) + free(((void**) ptr)[-1]); #endif } From d48be27f5aa018d398cf9369b2c664bee4ce6e19 Mon Sep 17 00:00:00 2001 From: mayeut Date: Wed, 21 Oct 2015 00:09:04 +0200 Subject: [PATCH 2/2] Generic aligned malloc implementation update. Update #642 --- src/lib/openjp2/opj_malloc.c | 84 ++++++++++++++++++++++-------------- 1 file changed, 51 insertions(+), 33 deletions(-) diff --git a/src/lib/openjp2/opj_malloc.c b/src/lib/openjp2/opj_malloc.c index e2ace0b8..04ef055c 100644 --- a/src/lib/openjp2/opj_malloc.c +++ b/src/lib/openjp2/opj_malloc.c @@ -33,7 +33,7 @@ #include "opj_includes.h" #ifndef SIZE_MAX -#define SIZE_MAX ((size_t) -1) +# define SIZE_MAX ((size_t) -1) #endif static INLINE void *opj_aligned_alloc_n(size_t alignment, size_t size) @@ -42,6 +42,8 @@ static INLINE void *opj_aligned_alloc_n(size_t alignment, size_t size) /* alignment shall be power of 2 */ assert( (alignment != 0U) && ((alignment & (alignment - 1U)) == 0U)); + /* alignment shall be at least sizeof(void*) */ + assert( alignment >= sizeof(void*)); if (size == 0U) { /* prevent implementation defined behavior of realloc */ return NULL; @@ -65,26 +67,34 @@ static INLINE void *opj_aligned_alloc_n(size_t alignment, size_t size) #else /* * Generic aligned malloc implementation. - * Uses ptrdiff_t for the integer manipulation of the pointer, as - * uintptr_t is not available in C89. + * Uses size_t offset for the integer manipulation of the pointer, + * as uintptr_t is not available in C89 to do + * bitwise operations on the pointer itself. */ + alignment--; { - ptrdiff_t mask; - void *mem; + size_t offset; + OPJ_UINT8 *mem; /* Room for padding and extra pointer stored in front of allocated area */ - size_t overhead = (alignment - 1) + sizeof(void *); + size_t overhead = alignment + sizeof(void *); + + /* let's be extra careful */ + assert(alignment <= (SIZE_MAX - sizeof(void *))); /* Avoid integer overflow */ - if (size > SIZE_MAX - overhead) + if (size > (SIZE_MAX - overhead)) { return NULL; + } - mem = malloc(size + overhead); - if (!mem) + mem = (OPJ_UINT8*)malloc(size + overhead); + if (mem == NULL) { return mem; - - mask = ~(ptrdiff_t)(alignment - 1); - ptr = (void *) ((ptrdiff_t) (mem + overhead) & mask); + } + /* offset = ((alignment + 1U) - ((size_t)(mem + sizeof(void*)) & alignment)) & alignment; */ + /* Use the fact that alignment + 1U is a power of 2 */ + offset = ((alignment ^ ((size_t)(mem + sizeof(void*)) & alignment)) + 1U) & alignment; + ptr = (void *)(mem + sizeof(void*) + offset); ((void**) ptr)[-1] = mem; } #endif @@ -96,6 +106,8 @@ static INLINE void *opj_aligned_realloc_n(void *ptr, size_t alignment, size_t ne /* alignment shall be power of 2 */ assert( (alignment != 0U) && ((alignment & (alignment - 1U)) == 0U)); + /* alignment shall be at least sizeof(void*) */ + assert( alignment >= sizeof(void*)); if (new_size == 0U) { /* prevent implementation defined behavior of realloc */ return NULL; @@ -123,42 +135,47 @@ static INLINE void *opj_aligned_realloc_n(void *ptr, size_t alignment, size_t ne #elif defined(HAVE__ALIGNED_MALLOC) r_ptr = _aligned_realloc( ptr, new_size, alignment ); #else + if (ptr == NULL) { + return opj_aligned_alloc_n(alignment, new_size); + } + alignment--; { - void *oldmem, *newmem; - size_t overhead = (alignment - 1) + sizeof(void *); - - if (new_size == 0) { - my_aligned_free(ptr); - return NULL; - } + void *oldmem; + OPJ_UINT8 *newmem; + size_t overhead = alignment + sizeof(void *); + + /* let's be extra careful */ + assert(alignment <= (SIZE_MAX - sizeof(void *))); /* Avoid integer overflow */ - if (new_size > SIZE_MAX - overhead) + if (new_size > SIZE_MAX - overhead) { return NULL; - + } + oldmem = ((void**) ptr)[-1]; - newmem = realloc(oldmem, new_size + overhead); - if (!newmem) + newmem = (OPJ_UINT8*)realloc(oldmem, new_size + overhead); + if (newmem == NULL) { return newmem; + } if (newmem == oldmem) { r_ptr = ptr; } else { - ptrdiff_t old_offset, new_offset; - ptrdiff_t mask; + size_t old_offset; + size_t new_offset; /* realloc created a new copy, realign the copied memory block */ - old_offset = (char *) ptr - (char *) oldmem; + old_offset = (size_t)(ptr - oldmem); - mask = ~(ptrdiff_t)(alignment - 1); - r_ptr = (void *) ((ptrdiff_t) (newmem + overhead) & mask); - - new_offset = (char *) r_ptr - (char *) newmem; + /* offset = ((alignment + 1U) - ((size_t)(mem + sizeof(void*)) & alignment)) & alignment; */ + /* Use the fact that alignment + 1U is a power of 2 */ + new_offset = ((alignment ^ ((size_t)(newmem + sizeof(void*)) & alignment)) + 1U) & alignment; + new_offset += sizeof(void*); + r_ptr = (void *)(newmem + new_offset); if (new_offset != old_offset) { - memmove((char *) newmem + new_offset, (char *) newmem + old_offset, - new_size); + memmove(newmem + new_offset, newmem + old_offset, new_size); } ((void**) r_ptr)[-1] = newmem; } @@ -199,8 +216,9 @@ void opj_aligned_free(void* ptr) _aligned_free( ptr ); #else /* Generic implementation has malloced pointer stored in front of used area */ - if (ptr) + if (ptr != NULL) { free(((void**) ptr)[-1]); + } #endif }