Generic aligned malloc implementation update.

Update #642

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
+   * Uses size_t offset for the integer manipulation of the pointer,
-   * uintptr_t is not available in C89.
+   * as uintptr_t is not available in C89 to do 
+   * bitwise operations on the pointer itself.
    */
+  alignment--;
   {
-    ptrdiff_t mask;
+    size_t offset;
-    void *mem;
+    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);
+    mem = (OPJ_UINT8*)malloc(size + overhead);
-    if (!mem)
+    if (mem == NULL) {
       return mem;
-
+    }
-    mask = ~(ptrdiff_t)(alignment - 1);
+    /* offset = ((alignment + 1U) - ((size_t)(mem + sizeof(void*)) & alignment)) & alignment; */
-    ptr = (void *) ((ptrdiff_t) (mem + overhead) & mask);
+    /* 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;
+    void *oldmem;
-    size_t overhead = (alignment - 1) + sizeof(void *);
+    OPJ_UINT8 *newmem;
-    
+    size_t overhead = alignment + sizeof(void *);
-    if (new_size == 0) {
+
-      my_aligned_free(ptr);
+    /* let's be extra careful */
-      return NULL;
+    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);
+    newmem = (OPJ_UINT8*)realloc(oldmem, new_size + overhead);
-    if (!newmem)
+    if (newmem == NULL) {
       return newmem;
+    }
 
     if (newmem == oldmem) {
       r_ptr = ptr;
     }
     else {
-      ptrdiff_t old_offset, new_offset;
+      size_t old_offset;
-      ptrdiff_t mask;
+      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);
+      /* offset = ((alignment + 1U) - ((size_t)(mem + sizeof(void*)) & alignment)) & alignment; */
-      r_ptr = (void *) ((ptrdiff_t) (newmem + overhead) & mask);
+      /* Use the fact that alignment + 1U is a power of 2 */
-
+      new_offset  = ((alignment ^ ((size_t)(newmem + sizeof(void*)) & alignment)) + 1U) & alignment;
-      new_offset = (char *) r_ptr - (char *) newmem;
+			new_offset += sizeof(void*);
+      r_ptr = (void *)(newmem + new_offset);
 
       if (new_offset != old_offset) {
-	memmove((char *) newmem + new_offset, (char *) newmem + old_offset,
+        memmove(newmem + new_offset, newmem + old_offset, new_size);
-		      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
 }