Port the gmalloc.c allocator from the CVS trunk of Emacs.

This includes various enhancements and fixes, including a
serious bug caused by using gmalloc's allocation and free
functions and the system version of posix_memalign().

PR:             ports/114993
Submitted by:   Gardner Bell
Reviewed by:    pav

2 files changed, 607 insertions, 1 deletions

diff --git a/editors/emacs/Makefile b/editors/emacs/Makefile
index 483a2cbb1a1a..bf8d1df699e0 100644
--- a/editors/emacs/Makefile
+++ b/editors/emacs/Makefile
@@ -7,7 +7,7 @@
 
 PORTNAME=	emacs
 PORTVERSION=	${EMACS_VER}
-PORTREVISION=	1
+PORTREVISION=	2
 CATEGORIES=	editors ipv6
 MASTER_SITES=	${MASTER_SITE_GNU}
 MASTER_SITE_SUBDIR=	${PORTNAME}
diff --git a/editors/emacs/files/patch-src-gmalloc.c b/editors/emacs/files/patch-src-gmalloc.c
new file mode 100644
index 000000000000..c46344980d9a
--- /dev/null
+++ b/editors/emacs/files/patch-src-gmalloc.c
@@ -0,0 +1,606 @@
+--- ./src/gmalloc.c.orig	2007-09-27 19:31:50.000000000 +0300
++++ ./src/gmalloc.c	2007-09-27 19:31:54.000000000 +0300
+@@ -1,9 +1,6 @@
+ /* This file is no longer automatically generated from libc.  */
+ 
+ #define _MALLOC_INTERNAL
+-#ifdef HAVE_GTK_AND_PTHREAD
+-#define USE_PTHREAD
+-#endif
+ 
+ /* The malloc headers and source files from the C library follow here.  */
+ 
+@@ -40,6 +37,10 @@
+ #include <config.h>
+ #endif
+ 
++#ifdef HAVE_GTK_AND_PTHREAD
++#define USE_PTHREAD
++#endif
++
+ #if ((defined __cplusplus || (defined (__STDC__) && __STDC__) \
+       || defined STDC_HEADERS || defined PROTOTYPES) \
+      && ! defined (BROKEN_PROTOTYPES))
+@@ -128,6 +129,8 @@
+ #if ! (defined (_MALLOC_INTERNAL) && __DJGPP__ - 0 == 1) /* Avoid conflict.  */
+ extern __ptr_t memalign PP ((__malloc_size_t __alignment,
+ 			     __malloc_size_t __size));
++extern int posix_memalign PP ((__ptr_t *, __malloc_size_t,
++			       __malloc_size_t size));
+ #endif
+ 
+ /* Allocate SIZE bytes on a page boundary.  */
+@@ -135,6 +138,10 @@
+ extern __ptr_t valloc PP ((__malloc_size_t __size));
+ #endif
+ 
++#ifdef USE_PTHREAD
++/* Set up mutexes and make malloc etc. thread-safe.  */
++extern void malloc_enable_thread PP ((void));
++#endif
+ 
+ #ifdef _MALLOC_INTERNAL
+ 
+@@ -235,14 +242,38 @@
+ extern __ptr_t _malloc_internal PP ((__malloc_size_t __size));
+ extern __ptr_t _realloc_internal PP ((__ptr_t __ptr, __malloc_size_t __size));
+ extern void _free_internal PP ((__ptr_t __ptr));
++extern __ptr_t _malloc_internal_nolock PP ((__malloc_size_t __size));
++extern __ptr_t _realloc_internal_nolock PP ((__ptr_t __ptr, __malloc_size_t __size));
++extern void _free_internal_nolock PP ((__ptr_t __ptr));
+ 
+ #ifdef USE_PTHREAD
+-extern pthread_mutex_t _malloc_mutex;
+-#define LOCK()     pthread_mutex_lock (&_malloc_mutex)
+-#define UNLOCK()   pthread_mutex_unlock (&_malloc_mutex)
++extern pthread_mutex_t _malloc_mutex, _aligned_blocks_mutex;
++extern int _malloc_thread_enabled_p;
++#define LOCK()					\
++  do {						\
++    if (_malloc_thread_enabled_p)		\
++      pthread_mutex_lock (&_malloc_mutex);	\
++  } while (0)
++#define UNLOCK()				\
++  do {						\
++    if (_malloc_thread_enabled_p)		\
++      pthread_mutex_unlock (&_malloc_mutex);	\
++  } while (0)
++#define LOCK_ALIGNED_BLOCKS()				\
++  do {							\
++    if (_malloc_thread_enabled_p)			\
++      pthread_mutex_lock (&_aligned_blocks_mutex);	\
++  } while (0)
++#define UNLOCK_ALIGNED_BLOCKS()				\
++  do {							\
++    if (_malloc_thread_enabled_p)			\
++      pthread_mutex_unlock (&_aligned_blocks_mutex);	\
++  } while (0)
+ #else
+ #define LOCK()
+ #define UNLOCK()
++#define LOCK_ALIGNED_BLOCKS()
++#define UNLOCK_ALIGNED_BLOCKS()
+ #endif
+ 
+ #endif /* _MALLOC_INTERNAL.  */
+@@ -373,7 +404,7 @@
+ extern __ptr_t bss_sbrk PP ((ptrdiff_t __size));
+ extern int bss_sbrk_did_unexec;
+ #endif
+-__ptr_t (*__morecore) PP ((ptrdiff_t __size)) = __default_morecore;
++__ptr_t (*__morecore) PP ((__malloc_ptrdiff_t __size)) = __default_morecore;
+ 
+ /* Debugging hook for `malloc'.  */
+ __ptr_t (*__malloc_hook) PP ((__malloc_size_t __size));
+@@ -553,8 +584,49 @@
+ }
+ 
+ #ifdef USE_PTHREAD
+-static pthread_once_t malloc_init_once_control = PTHREAD_ONCE_INIT;
+-pthread_mutex_t _malloc_mutex;
++pthread_mutex_t _malloc_mutex = PTHREAD_MUTEX_INITIALIZER;
++pthread_mutex_t _aligned_blocks_mutex = PTHREAD_MUTEX_INITIALIZER;
++int _malloc_thread_enabled_p;
++
++static void
++malloc_atfork_handler_prepare ()
++{
++  LOCK ();
++  LOCK_ALIGNED_BLOCKS ();
++}
++
++static void
++malloc_atfork_handler_parent ()
++{
++  UNLOCK_ALIGNED_BLOCKS ();
++  UNLOCK ();
++}
++
++static void
++malloc_atfork_handler_child ()
++{
++  UNLOCK_ALIGNED_BLOCKS ();
++  UNLOCK ();
++}
++
++/* Set up mutexes and make malloc etc. thread-safe.  */
++void
++malloc_enable_thread ()
++{
++  if (_malloc_thread_enabled_p)
++    return;
++
++  /* Some pthread implementations call malloc for statically
++     initialized mutexes when they are used first.  To avoid such a
++     situation, we initialize mutexes here while their use is
++     disabled in malloc etc.  */
++  pthread_mutex_init (&_malloc_mutex, NULL);
++  pthread_mutex_init (&_aligned_blocks_mutex, NULL);
++  pthread_atfork (malloc_atfork_handler_prepare,
++		  malloc_atfork_handler_parent,
++		  malloc_atfork_handler_child);
++  _malloc_thread_enabled_p = 1;
++}
+ #endif
+ 
+ static void
+@@ -567,17 +639,6 @@
+   if (__malloc_initialize_hook)
+     (*__malloc_initialize_hook) ();
+ 
+-#ifdef USE_PTHREAD
+-  {
+-    pthread_mutexattr_t attr;
+-
+-    pthread_mutexattr_init (&attr);
+-    pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
+-    pthread_mutex_init (&_malloc_mutex, &attr);
+-    pthread_mutexattr_destroy (&attr);
+-  }
+-#endif
+-
+   heapsize = HEAP / BLOCKSIZE;
+   _heapinfo = (malloc_info *) align (heapsize * sizeof (malloc_info));
+   if (_heapinfo == NULL)
+@@ -596,18 +657,16 @@
+   return;
+ }
+ 
+-/* Set everything up and remember that we have.  */
++/* Set everything up and remember that we have.
++   main will call malloc which calls this function.  That is before any threads
++   or signal handlers has been set up, so we don't need thread protection.  */
+ int
+ __malloc_initialize ()
+ {
+-#ifdef USE_PTHREAD
+-  pthread_once (&malloc_init_once_control, malloc_initialize_1);
+-#else
+   if (__malloc_initialized)
+     return 0;
+ 
+   malloc_initialize_1 ();
+-#endif
+ 
+   return __malloc_initialized;
+ }
+@@ -616,9 +675,9 @@
+ 
+ /* Get neatly aligned memory, initializing or
+    growing the heap info table as necessary. */
+-static __ptr_t morecore PP ((__malloc_size_t));
++static __ptr_t morecore_nolock PP ((__malloc_size_t));
+ static __ptr_t
+-morecore (size)
++morecore_nolock (size)
+      __malloc_size_t size;
+ {
+   __ptr_t result;
+@@ -661,7 +720,7 @@
+ 	     `morecore_recursing' flag and return null.  */
+ 	  int save = errno;	/* Don't want to clobber errno with ENOMEM.  */
+ 	  morecore_recursing = 1;
+-	  newinfo = (malloc_info *) _realloc_internal
++	  newinfo = (malloc_info *) _realloc_internal_nolock
+ 	    (_heapinfo, newsize * sizeof (malloc_info));
+ 	  morecore_recursing = 0;
+ 	  if (newinfo == NULL)
+@@ -717,7 +776,7 @@
+       /* Reset _heaplimit so _free_internal never decides
+ 	 it can relocate or resize the info table.  */
+       _heaplimit = 0;
+-      _free_internal (oldinfo);
++      _free_internal_nolock (oldinfo);
+       PROTECT_MALLOC_STATE (0);
+ 
+       /* The new heap limit includes the new table just allocated.  */
+@@ -732,7 +791,7 @@
+ 
+ /* Allocate memory from the heap.  */
+ __ptr_t
+-_malloc_internal (size)
++_malloc_internal_nolock (size)
+      __malloc_size_t size;
+ {
+   __ptr_t result;
+@@ -752,7 +811,6 @@
+     return NULL;
+ #endif
+ 
+-  LOCK ();
+   PROTECT_MALLOC_STATE (0);
+ 
+   if (size < sizeof (struct list))
+@@ -802,8 +860,10 @@
+ 	  /* No free fragments of the desired size, so get a new block
+ 	     and break it into fragments, returning the first.  */
+ #ifdef GC_MALLOC_CHECK
+-	  result = _malloc_internal (BLOCKSIZE);
++	  result = _malloc_internal_nolock (BLOCKSIZE);
+ 	  PROTECT_MALLOC_STATE (0);
++#elif defined (USE_PTHREAD)
++	  result = _malloc_internal_nolock (BLOCKSIZE);
+ #else
+ 	  result = malloc (BLOCKSIZE);
+ #endif
+@@ -874,7 +934,7 @@
+  		  _heaplimit += wantblocks - lastblocks;
+ 		  continue;
+ 		}
+-	      result = morecore (wantblocks * BLOCKSIZE);
++	      result = morecore_nolock (wantblocks * BLOCKSIZE);
+ 	      if (result == NULL)
+ 		goto out;
+ 	      block = BLOCK (result);
+@@ -932,7 +992,19 @@
+ 
+   PROTECT_MALLOC_STATE (1);
+  out:
++  return result;
++}
++
++__ptr_t
++_malloc_internal (size)
++     __malloc_size_t size;
++{
++  __ptr_t result;
++
++  LOCK ();
++  result = _malloc_internal_nolock (size);
+   UNLOCK ();
++
+   return result;
+ }
+ 
+@@ -940,10 +1012,21 @@
+ malloc (size)
+      __malloc_size_t size;
+ {
++  __ptr_t (*hook) (__malloc_size_t);
++
+   if (!__malloc_initialized && !__malloc_initialize ())
+     return NULL;
+ 
+-  return (__malloc_hook != NULL ? *__malloc_hook : _malloc_internal) (size);
++  /* Copy the value of __malloc_hook to an automatic variable in case
++     __malloc_hook is modified in another thread between its
++     NULL-check and the use.
++
++     Note: Strictly speaking, this is not a right solution.  We should
++     use mutexes to access non-read-only variables that are shared
++     among multiple threads.  We just leave it for compatibility with
++     glibc malloc (i.e., assignments to __malloc_hook) for now.  */
++  hook = __malloc_hook;
++  return (hook != NULL ? *hook : _malloc_internal) (size);
+ }
+ 
+ #ifndef _LIBC
+@@ -1024,9 +1107,9 @@
+ struct alignlist *_aligned_blocks = NULL;
+ 
+ /* Return memory to the heap.
+-   Like `free' but don't call a __free_hook if there is one.  */
++   Like `_free_internal' but don't lock mutex.  */
+ void
+-_free_internal (ptr)
++_free_internal_nolock (ptr)
+      __ptr_t ptr;
+ {
+   int type;
+@@ -1043,9 +1126,9 @@
+   if (ptr == NULL)
+     return;
+ 
+-  LOCK ();
+   PROTECT_MALLOC_STATE (0);
+ 
++  LOCK_ALIGNED_BLOCKS ();
+   for (l = _aligned_blocks; l != NULL; l = l->next)
+     if (l->aligned == ptr)
+       {
+@@ -1053,6 +1136,7 @@
+ 	ptr = l->exact;
+ 	break;
+       }
++  UNLOCK_ALIGNED_BLOCKS ();
+ 
+   block = BLOCK (ptr);
+ 
+@@ -1158,7 +1242,7 @@
+ 		 table's blocks to the system before we have copied them to
+ 		 the new location.  */
+ 	      _heaplimit = 0;
+-	      _free_internal (_heapinfo);
++	      _free_internal_nolock (_heapinfo);
+ 	      _heaplimit = oldlimit;
+ 
+ 	      /* Tell malloc to search from the beginning of the heap for
+@@ -1166,8 +1250,8 @@
+ 	      _heapindex = 0;
+ 
+ 	      /* Allocate new space for the info table and move its data.  */
+-	      newinfo = (malloc_info *) _malloc_internal (info_blocks
+-							  * BLOCKSIZE);
++	      newinfo = (malloc_info *) _malloc_internal_nolock (info_blocks
++								 * BLOCKSIZE);
+ 	      PROTECT_MALLOC_STATE (0);
+ 	      memmove (newinfo, _heapinfo, info_blocks * BLOCKSIZE);
+ 	      _heapinfo = newinfo;
+@@ -1230,8 +1314,8 @@
+ 	  _chunks_free -= BLOCKSIZE >> type;
+ 	  _bytes_free -= BLOCKSIZE;
+ 
+-#ifdef GC_MALLOC_CHECK
+-	  _free_internal (ADDRESS (block));
++#if defined (GC_MALLOC_CHECK) || defined (USE_PTHREAD)
++	  _free_internal_nolock (ADDRESS (block));
+ #else
+ 	  free (ADDRESS (block));
+ #endif
+@@ -1269,6 +1353,16 @@
+     }
+ 
+   PROTECT_MALLOC_STATE (1);
++}
++
++/* Return memory to the heap.
++   Like `free' but don't call a __free_hook if there is one.  */
++void
++_free_internal (ptr)
++     __ptr_t ptr;
++{
++  LOCK ();
++  _free_internal_nolock (ptr);
+   UNLOCK ();
+ }
+ 
+@@ -1278,8 +1372,10 @@
+ free (ptr)
+      __ptr_t ptr;
+ {
+-  if (__free_hook != NULL)
+-    (*__free_hook) (ptr);
++  void (*hook) (__ptr_t) = __free_hook;
++
++  if (hook != NULL)
++    (*hook) (ptr);
+   else
+     _free_internal (ptr);
+ }
+@@ -1415,7 +1511,7 @@
+    new region.  This module has incestuous knowledge of the
+    internals of both free and malloc. */
+ __ptr_t
+-_realloc_internal (ptr, size)
++_realloc_internal_nolock (ptr, size)
+      __ptr_t ptr;
+      __malloc_size_t size;
+ {
+@@ -1425,15 +1521,14 @@
+ 
+   if (size == 0)
+     {
+-      _free_internal (ptr);
+-      return _malloc_internal (0);
++      _free_internal_nolock (ptr);
++      return _malloc_internal_nolock (0);
+     }
+   else if (ptr == NULL)
+-    return _malloc_internal (size);
++    return _malloc_internal_nolock (size);
+ 
+   block = BLOCK (ptr);
+ 
+-  LOCK ();
+   PROTECT_MALLOC_STATE (0);
+ 
+   type = _heapinfo[block].busy.type;
+@@ -1443,11 +1538,11 @@
+       /* Maybe reallocate a large block to a small fragment.  */
+       if (size <= BLOCKSIZE / 2)
+ 	{
+-	  result = _malloc_internal (size);
++	  result = _malloc_internal_nolock (size);
+ 	  if (result != NULL)
+ 	    {
+ 	      memcpy (result, ptr, size);
+-	      _free_internal (ptr);
++	      _free_internal_nolock (ptr);
+ 	      goto out;
+ 	    }
+ 	}
+@@ -1467,7 +1562,7 @@
+ 	     Now we will free this chunk; increment the statistics counter
+ 	     so it doesn't become wrong when _free_internal decrements it.  */
+ 	  ++_chunks_used;
+-	  _free_internal (ADDRESS (block + blocks));
++	  _free_internal_nolock (ADDRESS (block + blocks));
+ 	  result = ptr;
+ 	}
+       else if (blocks == _heapinfo[block].busy.info.size)
+@@ -1482,8 +1577,8 @@
+ 	  /* Prevent free from actually returning memory to the system.  */
+ 	  oldlimit = _heaplimit;
+ 	  _heaplimit = 0;
+-	  _free_internal (ptr);
+-	  result = _malloc_internal (size);
++	  _free_internal_nolock (ptr);
++	  result = _malloc_internal_nolock (size);
+ 	  PROTECT_MALLOC_STATE (0);
+ 	  if (_heaplimit == 0)
+ 	    _heaplimit = oldlimit;
+@@ -1493,13 +1588,13 @@
+ 		 the thing we just freed.  Unfortunately it might
+ 		 have been coalesced with its neighbors.  */
+ 	      if (_heapindex == block)
+-	        (void) _malloc_internal (blocks * BLOCKSIZE);
++	        (void) _malloc_internal_nolock (blocks * BLOCKSIZE);
+ 	      else
+ 		{
+ 		  __ptr_t previous
+-		    = _malloc_internal ((block - _heapindex) * BLOCKSIZE);
+-		  (void) _malloc_internal (blocks * BLOCKSIZE);
+-		  _free_internal (previous);
++		    = _malloc_internal_nolock ((block - _heapindex) * BLOCKSIZE);
++		  (void) _malloc_internal_nolock (blocks * BLOCKSIZE);
++		  _free_internal_nolock (previous);
+ 		}
+ 	      goto out;
+ 	    }
+@@ -1519,18 +1614,31 @@
+ 	{
+ 	  /* The new size is different; allocate a new space,
+ 	     and copy the lesser of the new size and the old. */
+-	  result = _malloc_internal (size);
++	  result = _malloc_internal_nolock (size);
+ 	  if (result == NULL)
+ 	    goto out;
+ 	  memcpy (result, ptr, min (size, (__malloc_size_t) 1 << type));
+-	  _free_internal (ptr);
++	  _free_internal_nolock (ptr);
+ 	}
+       break;
+     }
+ 
+   PROTECT_MALLOC_STATE (1);
+  out:
++  return result;
++}
++
++__ptr_t
++_realloc_internal (ptr, size)
++     __ptr_t ptr;
++     __malloc_size_t size;
++{
++  __ptr_t result;
++
++  LOCK();
++  result = _realloc_internal_nolock (ptr, size);
+   UNLOCK ();
++
+   return result;
+ }
+ 
+@@ -1539,11 +1647,13 @@
+      __ptr_t ptr;
+      __malloc_size_t size;
+ {
++  __ptr_t (*hook) (__ptr_t, __malloc_size_t);
++
+   if (!__malloc_initialized && !__malloc_initialize ())
+     return NULL;
+ 
+-  return (__realloc_hook != NULL ? *__realloc_hook : _realloc_internal)
+-    (ptr, size);
++  hook = __realloc_hook;
++  return (hook != NULL ? *hook : _realloc_internal) (ptr, size);
+ }
+ /* Copyright (C) 1991, 1992, 1994 Free Software Foundation, Inc.
+ 
+@@ -1681,9 +1791,10 @@
+ {
+   __ptr_t result;
+   unsigned long int adj, lastadj;
++  __ptr_t (*hook) (__malloc_size_t, __malloc_size_t) = __memalign_hook;
+ 
+-  if (__memalign_hook)
+-    return (*__memalign_hook) (alignment, size);
++  if (hook)
++    return (*hook) (alignment, size);
+ 
+   /* Allocate a block with enough extra space to pad the block with up to
+      (ALIGNMENT - 1) bytes if necessary.  */
+@@ -1718,6 +1829,7 @@
+ 	 of an allocated block.  */
+ 
+       struct alignlist *l;
++      LOCK_ALIGNED_BLOCKS ();
+       for (l = _aligned_blocks; l != NULL; l = l->next)
+ 	if (l->aligned == NULL)
+ 	  /* This slot is free.  Use it.  */
+@@ -1725,21 +1837,58 @@
+       if (l == NULL)
+ 	{
+ 	  l = (struct alignlist *) malloc (sizeof (struct alignlist));
+-	  if (l == NULL)
++	  if (l != NULL)
+ 	    {
+-	      free (result);
+-	      return NULL;
++	      l->next = _aligned_blocks;
++	      _aligned_blocks = l;
+ 	    }
+-	  l->next = _aligned_blocks;
+-	  _aligned_blocks = l;
+ 	}
+-      l->exact = result;
+-      result = l->aligned = (char *) result + alignment - adj;
++      if (l != NULL)
++	{
++	  l->exact = result;
++	  result = l->aligned = (char *) result + alignment - adj;
++	}
++      UNLOCK_ALIGNED_BLOCKS ();
++      if (l == NULL)
++	{
++	  free (result);
++	  result = NULL;
++	}
+     }
+ 
+   return result;
+ }
+ 
++#ifndef ENOMEM
++#define ENOMEM 12
++#endif
++
++#ifndef EINVAL
++#define EINVAL 22
++#endif
++
++int
++posix_memalign (memptr, alignment, size)
++     __ptr_t *memptr;
++     __malloc_size_t alignment;
++     __malloc_size_t size;
++{
++  __ptr_t mem;
++
++  if (alignment == 0
++      || alignment % sizeof (__ptr_t) != 0
++      || (alignment & (alignment - 1)) != 0)
++    return EINVAL;
++
++  mem = memalign (alignment, size);
++  if (mem == NULL)
++    return ENOMEM;
++
++  *memptr = mem;
++
++  return 0;
++}
++
+ #endif /* Not DJGPP v1 */
+ /* Allocate memory on a page boundary.
+    Copyright (C) 1991, 92, 93, 94, 96 Free Software Foundation, Inc.