Pulled in aligned_alloc from dlmalloc.c (dlmemalign).

diff --git a/includes/stdlib.h b/includes/stdlib.h
index 157ebee3c1c95481f0bfc44ccc0c70c967f73622..b94ceafeeeea2fca5a61fe6fde5b11b12f4c2b69 100644 (file)
--- a/includes/stdlib.h
+++ b/includes/stdlib.h
@@ -95,19 +95,26 @@ void srand( unsigned int seed ) _PDCLIB_nothrow;
 
 /* Memory management functions */
 
-/* Allocate a chunk of heap memory of given size. If request could not be
+/* Allocate a chunk of memory of given size. If request could not be
    satisfied, return NULL. Otherwise, return a pointer to the allocated
    memory. Memory contents are undefined.
 */
 void * malloc( size_t size ) _PDCLIB_nothrow;
 
-/* Allocate a chunk of heap memory that is large enough to hold nmemb elements
-   of the given size, and zero-initialize that memory. If request could not be
+/* Allocate a chunk of memory that is large enough to hold nmemb elements of
+   the given size, and zero-initialize that memory. If request could not be
    satisfied, return NULL. Otherwise, return a pointer to the allocated
    memory.
 */
 void * calloc( size_t nmemb, size_t size ) _PDCLIB_nothrow;
 
+/* Allocate a chunk of memory of given size, with specified alignment (which
+   must be a power of two; if it is not, the next greater power of two is
+   used). If request could not be satisfied, return NULL. Otherwise, return
+   a pointer to the allocated memory.
+*/
+void * aligned_alloc( size_t alignment, size_t size ) _PDCLIB_nothrow;
+
 /* De-allocate a chunk of heap memory previously allocated using malloc(),
    calloc(), or realloc(), and pointed to by ptr. If ptr does not match a
    pointer previously returned by the mentioned allocation functions, or

diff --git a/opt/dlmalloc/dlmalloc.c b/opt/dlmalloc/dlmalloc.c
index 865b5b95afa46c04084dc241ceff38589d160b17..dd1126a26874a9bcb2cee80db6965cd5395cfd5b 100644 (file)
--- a/opt/dlmalloc/dlmalloc.c
+++ b/opt/dlmalloc/dlmalloc.c
@@ -814,7 +814,7 @@ extern "C" {
 #define dlcalloc               calloc\r
 #define dlfree                 free\r
 #define dlmalloc               malloc\r
-#define dlmemalign             memalign\r
+#define dlmemalign             aligned_alloc\r
 #define dlposix_memalign       posix_memalign\r
 #define dlrealloc              realloc\r
 #define dlrealloc_in_place     realloc_in_place\r
@@ -893,6 +893,20 @@ DLMALLOC_EXPORT void* dlcalloc(size_t, size_t);
 */\r
 DLMALLOC_EXPORT void* dlrealloc(void*, size_t);\r
 \r
+/*\r
+  memalign(size_t alignment, size_t n);\r
+  Returns a pointer to a newly allocated chunk of n bytes, aligned\r
+  in accord with the alignment argument.\r
+\r
+  The alignment argument should be a power of two. If the argument is\r
+  not a power of two, the nearest greater power is used.\r
+  8-byte alignment is guaranteed by normal malloc calls, so don't\r
+  bother calling memalign with an argument of 8 or less.\r
+\r
+  Overreliance on memalign is a sure way to fragment space.\r
+*/\r
+DLMALLOC_EXPORT void* dlmemalign(size_t, size_t);\r
+\r
 #endif\r
 \r
 /*\r
@@ -910,20 +924,6 @@ DLMALLOC_EXPORT void* dlrealloc(void*, size_t);
 */\r
 DLMALLOC_EXPORT void* dlrealloc_in_place(void*, size_t);\r
 \r
-/*\r
-  memalign(size_t alignment, size_t n);\r
-  Returns a pointer to a newly allocated chunk of n bytes, aligned\r
-  in accord with the alignment argument.\r
-\r
-  The alignment argument should be a power of two. If the argument is\r
-  not a power of two, the nearest greater power is used.\r
-  8-byte alignment is guaranteed by normal malloc calls, so don't\r
-  bother calling memalign with an argument of 8 or less.\r
-\r
-  Overreliance on memalign is a sure way to fragment space.\r
-*/\r
-DLMALLOC_EXPORT void* dlmemalign(size_t, size_t);\r
-\r
 /*\r
   int posix_memalign(void** pp, size_t alignment, size_t n);\r
   Allocates a chunk of n bytes, aligned in accord with the alignment\r