1 files changed, 92 insertions, 6 deletions

diff --git a/src/lib/openjp2/opj_malloc.c b/src/lib/openjp2/opj_malloc.c
index 3bbf80d8..a4aea30f 100644
--- a/src/lib/openjp2/opj_malloc.c
+++ b/src/lib/openjp2/opj_malloc.c
@@ -32,12 +32,18 @@
 #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;
 
   /* 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;
@@ -59,8 +65,38 @@ 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 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--;
+  {
+    size_t offset;
+    OPJ_UINT8 *mem;
+
+    /* Room for padding and extra pointer stored in front of allocated area */
+    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)) {
+      return NULL;
+    }
+
+    mem = (OPJ_UINT8*)malloc(size + overhead);
+    if (mem == NULL) {
+      return mem;
+    }
+    /* 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
   return ptr;
 }
@@ -70,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;
@@ -97,8 +135,51 @@ 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
+  if (ptr == NULL) {
+    return opj_aligned_alloc_n(alignment, new_size);
+  }
+  alignment--;
+  {
+    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) {
+      return NULL;
+    }
+		
+    oldmem = ((void**) ptr)[-1];
+    newmem = (OPJ_UINT8*)realloc(oldmem, new_size + overhead);
+    if (newmem == NULL) {
+      return newmem;
+    }
+
+    if (newmem == oldmem) {
+      r_ptr = ptr;
+    }
+    else {
+      size_t old_offset;
+      size_t new_offset;
+
+      /* realloc created a new copy, realign the copied memory block */
+      old_offset = (size_t)((OPJ_UINT8*)ptr - (OPJ_UINT8*)oldmem);
+
+      /* 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(newmem + new_offset, newmem + old_offset, new_size);
+      }
+      ((void**) r_ptr)[-1] = newmem;
+    }
+  }
 #endif
 	return r_ptr;
 }
@@ -129,10 +210,15 @@ 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 != NULL) {
+    free(((void**) ptr)[-1]);
+  }
 #endif
 }