Mail Archives: djgpp-workers/2001/01/07/00:32:06
While testing memalign/valloc with gcc and then my own sample test program, I found a
subtle problem that caused gcc and my test program to crash. If the amount of memory
between the unaligned pointer and the aligned pointer is 8 bytes, freeing that memory
caused the tag info to become corrupted (because 8 bytes = 4 bytes for begin tag + 4
bytes for end tag and no memory to use). This patch adds code to account for this.
Also, I'd like ask about checkin privs so other people don't have to check my stuff
in.
*** /dev/null Sun Jan 7 00:14:39 2001
--- include/libc/malloc.h Fri Jan 5 18:39:44 2001
***************
*** 0 ****
--- 1,40 ----
+ /* Copyright (C) 2001 DJ Delorie, see COPYING.DJ for details */
+ #ifndef __dj_include_libc_malloc_h__
+ #define __dj_include_libc_malloc_h__
+
+ #ifdef __cplusplus
+ extern "C" {
+ #endif
+
+ #ifndef __dj_ENFORCE_ANSI_FREESTANDING
+
+ #ifndef __STRICT_ANSI__
+
+ #ifndef _POSIX_SOURCE
+
+ typedef struct BLOCK {
+ size_t size;
+ struct BLOCK *next;
+ int bucket;
+ } BLOCK;
+
+ #define BEFORE(bp) ((BLOCK *)((char *)bp - *(int *)((char *)bp - 4) - 8))
+ #define BEFSZ(bp) (*(size_t *)((char *)bp - 4))
+ #define ENDSZ(bp) (*(size_t *)((char *)bp + bp->size + 4))
+ #define AFTER(bp) ((BLOCK *)((char *)bp + bp->size + 8))
+ #define DATA(bp) ((char *)&(bp->next))
+
+ #define ALIGN 8
+
+ #endif /* !_POSIX_SOURCE */
+ #endif /* !__STRICT_ANSI__ */
+ #endif /* !__dj_ENFORCE_ANSI_FREESTANDING */
+
+ #ifndef __dj_ENFORCE_FUNCTION_CALLS
+ #endif /* !__dj_ENFORCE_FUNCTION_CALLS */
+
+ #ifdef __cplusplus
+ }
+ #endif
+
+ #endif /* __dj_include_libc_atexit_h__ */
*** /dev/null Sun Jan 7 00:14:39 2001
--- src/libc/compat/stdlib/valloc.c Fri Jan 5 18:42:04 2001
***************
*** 0 ****
--- 1,10 ----
+ /* Copyright (C) 2001 DJ Delorie, see COPYING.DJ for details */
+
+ #include <unistd.h>
+ void *memalign (size_t, size_t);
+
+ void *
+ valloc (size_t amt)
+ {
+ return memalign (amt, getpagesize());
+ }
*** /dev/null Sun Jan 7 00:14:39 2001
--- src/libc/compat/stdlib/valloc.txh Fri Jan 5 18:27:08 2001
***************
*** 0 ****
--- 1,27 ----
+ @node valloc, memory
+ @subheading Syntax
+
+ @example
+ #include <stdlib.h>
+
+ void *valloc(size_t size);
+ @end example
+
+ @subheading Description
+
+ This function is just like @code{malloc} (@pxref{malloc}) except that the
+ returned pointer is always aligned to a CPU page boundary.
+
+ @subheading Return Value
+
+ A pointer to a newly allocated block of memory.
+
+ @subheading Portability
+
+ @portability !ansi, !posix
+
+ @subheading Example
+
+ @example
+ char *page = valloc(getpagesize());
+ @end example
*** /dev/null Sun Jan 7 00:14:39 2001
--- src/libc/compat/stdlib/memalign.c Sun Jan 7 00:14:32 2001
***************
*** 0 ****
--- 1,93 ----
+ /* Copyright (C) 2001 DJ Delorie, see COPYING.DJ for details */
+ #include <stdlib.h>
+ #include <libc/malloc.h>
+
+ /* Make VAL a multiple of ALIGN. */
+ static inline
+ size_t
+ align_val (size_t val, size_t align)
+ {
+ return ((val + (align - 1)) & ~(align - 1));
+ }
+
+ /* Split a chunk of previously allocated memory into two chunks so both can
+ be released with a call to free(). */
+ static void *
+ split_alloc (char *ptr, size_t split_pos)
+ {
+ BLOCK *b1, *b2;
+ char *split_ptr;
+
+ b1 = (BLOCK *)(ptr - 4);
+
+ /* Set location of second pointer and its block info. */
+ split_ptr = ptr + split_pos;
+ b2 = (BLOCK *)(split_ptr - 4);
+
+ /* Temporarily clear chunk-in-use bit so macros work correctly. */
+ b1->size &= ~1;
+
+ /* Set up the two blocks. */
+ b2->size = b1->size - split_pos;
+ b1->size = split_pos - 8;
+
+ ENDSZ(b1) = b1->size;
+ ENDSZ(b2) = b2->size;
+
+ /* Finish up by setting the chunk-in-use bit for the first chunk and
+ returning a pointer to the chunk just split off. */
+ ENDSZ(b1) |= 1;
+ b1->size |= 1;
+
+ ENDSZ(b2) |= 1;
+ b2->size |= 1;
+
+ return DATA(b2);
+ }
+
+ /* Return a block of memory AMT bytes long whose address is a multiple
+ ALIGN. ALIGN must be a power of 2. */
+
+ void *
+ memalign (size_t amt, size_t align)
+ {
+ char *ptr, *aligned_ptr;
+ BLOCK *b;
+ size_t alloc_size, before_size, after_size;
+
+ if (align != align_val(align, align))
+ return NULL;
+
+ if (align < ALIGN)
+ align = ALIGN;
+
+ amt = align_val (amt, ALIGN);
+ alloc_size = amt + align;
+
+ ptr = malloc(alloc_size);
+ if (ptr == NULL)
+ return ptr;
+
+ aligned_ptr = (char *)align_val((size_t)ptr, align);
+
+ /* Release the space between the malloc'ed pointer
+ and the aligned pointer, if any. */
+ before_size = (aligned_ptr - ptr);
+ if (before_size)
+ {
+ aligned_ptr = split_alloc (ptr, before_size);
+ free (ptr);
+ }
+
+ /* Release extra space after the aligned block. Avoid
+ creating an empty block. */
+ after_size = alloc_size - before_size - amt;
+ if (after_size >= 16)
+ {
+ char *after = split_alloc (aligned_ptr, amt + 8);
+ free (after);
+ }
+
+ return aligned_ptr;
+ }
+
*** /dev/null Sun Jan 7 00:14:39 2001
--- src/libc/compat/stdlib/memalign.txh Fri Jan 5 18:35:14 2001
***************
*** 0 ****
--- 1,28 ----
+ @node memalign, memory
+ @subheading Syntax
+
+ @example
+ #include <stdlib.h>
+
+ void *memalign(size_t size, size_t alignment);
+ @end example
+
+ @subheading Description
+
+ This function is just like @code{malloc} (@pxref{malloc}) except that the
+ returned pointer is always a multiple of @var{alignment}. @var{alignment}
+ must be a multiple of two.
+
+ @subheading Return Value
+
+ A pointer to a newly allocated block of memory.
+
+ @subheading Portability
+
+ @portability !ansi, !posix
+
+ @subheading Example
+
+ @example
+ char *page = memalign(getpagesize(), getpagesize());
+ @end example
*** include/stdlib.h.orig Sun Jan 7 00:05:42 2001
--- include/stdlib.h Sun Jan 7 00:07:18 2001
*************** long long llabs(long long _i);
*** 102,107 ****
--- 102,108 ----
lldiv_t lldiv(long long _numer, long long _denom);
void lcong48(unsigned short param[7]);
unsigned long lrand48(void);
+ void * memalign(size_t _size, size_t _align);
long mrand48(void);
unsigned long nrand48(unsigned short state[3]);
int putenv(const char *_val);
*************** long double _strtold(const char *_s, cha
*** 113,118 ****
--- 114,120 ----
long long strtoll(const char *_s, char **_endptr, int _base);
unsigned long long strtoull(const char *_s, char **_endptr, int _base);
void swab(const void *from, void *to, int nbytes);
+ void * valloc(size_t _amount);
#ifndef alloca
#define alloca __builtin_alloca
*** src/libc/compat/stdlib/makefile.orig Sun Jan 7 00:10:42 2001
--- src/libc/compat/stdlib/makefile Sun Jan 7 00:11:38 2001
*************** SRC += fcvtbuf.c
*** 22,27 ****
SRC += fcvt.c
SRC += gcvt.c
SRC += rand48.c
!
include $(TOP)/../makefile.inc
--- 22,28 ----
SRC += fcvt.c
SRC += gcvt.c
SRC += rand48.c
! SRC += memalign.c
! SRC += valloc.c
include $(TOP)/../makefile.inc
- Raw text -