bug#9119: [PATCH] modernize function definitions in gmalloc.c

bug#9119: [PATCH] modernize function definitions in gmalloc.c

[Daniel Colascione]

[-- Attachment #1: Type: text/plain, Size: 8207 bytes --]

The warnings were annoying me.

=== modified file 'src/ChangeLog'
--- src/ChangeLog	2011-07-18 20:32:34 +0000
+++ src/ChangeLog	2011-07-18 23:38:06 +0000
@@ -1,5 +1,7 @@
 2011-07-18  Daniel Colascione  <dan.colascione@gmail.com>

+	* gmalloc.c: modernize function definitions throughout.

 2011-07-18  Paul Eggert  <eggert@cs.ucla.edu>

=== modified file 'src/gmalloc.c'
--- src/gmalloc.c	2011-05-28 22:39:39 +0000
+++ src/gmalloc.c	2011-07-18 23:38:06 +0000
@@ -485,8 +485,7 @@
 /* Aligned allocation.  */
 static __ptr_t align PP ((__malloc_size_t));
 static __ptr_t
-align (size)
-     __malloc_size_t size;
+align (__malloc_size_t size)
 {
   __ptr_t result;
   unsigned long int adj;
@@ -520,9 +519,8 @@
    If we cannot get space at END, fail and return 0.  */
 static __ptr_t get_contiguous_space PP ((__malloc_ptrdiff_t, __ptr_t));
 static __ptr_t
-get_contiguous_space (size, position)
-     __malloc_ptrdiff_t size;
-     __ptr_t position;
+get_contiguous_space (__malloc_ptrdiff_t size,
+                      __ptr_t position)
 {
   __ptr_t before;
   __ptr_t after;
@@ -578,21 +576,21 @@
 int _malloc_thread_enabled_p;

 static void
-malloc_atfork_handler_prepare ()
+malloc_atfork_handler_prepare (void)
 {
   LOCK ();
   LOCK_ALIGNED_BLOCKS ();
 }

 static void
-malloc_atfork_handler_parent ()
+malloc_atfork_handler_parent (void)
 {
   UNLOCK_ALIGNED_BLOCKS ();
   UNLOCK ();
 }

 static void
-malloc_atfork_handler_child ()
+malloc_atfork_handler_child (void)
 {
   UNLOCK_ALIGNED_BLOCKS ();
   UNLOCK ();
@@ -600,7 +598,7 @@

 /* Set up mutexes and make malloc etc. thread-safe.  */
 void
-malloc_enable_thread ()
+malloc_enable_thread (void)
 {
   if (_malloc_thread_enabled_p)
     return;
@@ -619,7 +617,7 @@
 #endif

 static void
-malloc_initialize_1 ()
+malloc_initialize_1 (void)
 {
 #ifdef GC_MCHECK
   mcheck (NULL);
@@ -650,7 +648,7 @@
    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 ()
+__malloc_initialize (void)
 {
   if (__malloc_initialized)
     return 0;
@@ -666,8 +664,7 @@
    growing the heap info table as necessary. */
 static __ptr_t morecore_nolock PP ((__malloc_size_t));
 static __ptr_t
-morecore_nolock (size)
-     __malloc_size_t size;
+morecore_nolock (__malloc_size_t size)
 {
   __ptr_t result;
   malloc_info *newinfo, *oldinfo;
@@ -780,8 +777,7 @@

 /* Allocate memory from the heap.  */
 __ptr_t
-_malloc_internal_nolock (size)
-     __malloc_size_t size;
+_malloc_internal_nolock (__malloc_size_t size)
 {
   __ptr_t result;
   __malloc_size_t block, blocks, lastblocks, start;
@@ -980,8 +976,7 @@
 }

 __ptr_t
-_malloc_internal (size)
-     __malloc_size_t size;
+_malloc_internal (__malloc_size_t size)
 {
   __ptr_t result;

@@ -993,8 +988,7 @@
 }

 __ptr_t
-malloc (size)
-     __malloc_size_t size;
+malloc (__malloc_size_t size)
 {
   __ptr_t (*hook) (__malloc_size_t);

@@ -1019,23 +1013,19 @@
    and _realloc.  Make them use the GNU functions.  */

 __ptr_t
-_malloc (size)
-     __malloc_size_t size;
+_malloc (__malloc_size_t size)
 {
   return malloc (size);
 }

 void
-_free (ptr)
-     __ptr_t ptr;
+_free (__ptr_t ptr)
 {
   free (ptr);
 }

 __ptr_t
-_realloc (ptr, size)
-     __ptr_t ptr;
-     __malloc_size_t size;
+_realloc (__ptr_t ptr, __malloc_size_t size)
 {
   return realloc (ptr, size);
 }
@@ -1341,8 +1331,7 @@
 /* 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;
+_free_internal (__ptr_t ptr)
 {
   LOCK ();
   _free_internal_nolock (ptr);
@@ -1352,8 +1341,7 @@
 /* Return memory to the heap.  */

 void
-free (ptr)
-     __ptr_t ptr;
+free (__ptr_t ptr)
 {
   void (*hook) (__ptr_t) = __free_hook;

@@ -1368,8 +1356,7 @@
 weak_alias (free, cfree)
 #else
 void
-cfree (ptr)
-     __ptr_t ptr;
+cfree (__ptr_t ptr)
 {
   free (ptr);
 }
@@ -1417,10 +1404,9 @@
 /* Like bcopy except never gets confused by overlap.  */

 void
-__malloc_safe_bcopy (afrom, ato, size)
-     __ptr_t afrom;
-     __ptr_t ato;
-     __malloc_size_t size;
+__malloc_safe_bcopy (__ptr_t afrom,
+                     __ptr_t ato,
+                     __malloc_size_t size)
 {
   char *from = afrom, *to = ato;

@@ -1493,9 +1479,7 @@
    new region.  This module has incestuous knowledge of the
    internals of both free and malloc. */
 __ptr_t
-_realloc_internal_nolock (ptr, size)
-     __ptr_t ptr;
-     __malloc_size_t size;
+_realloc_internal_nolock (__ptr_t ptr, __malloc_size_t size)
 {
   __ptr_t result;
   int type;
@@ -1611,9 +1595,8 @@
 }

 __ptr_t
-_realloc_internal (ptr, size)
-     __ptr_t ptr;
-     __malloc_size_t size;
+_realloc_internal (__ptr_t ptr,
+                   __malloc_size_t size)
 {
   __ptr_t result;

@@ -1625,9 +1608,8 @@
 }

 __ptr_t
-realloc (ptr, size)
-     __ptr_t ptr;
-     __malloc_size_t size;
+realloc (__ptr_t ptr,
+         __malloc_size_t size)
 {
   __ptr_t (*hook) (__ptr_t, __malloc_size_t);

@@ -1665,9 +1647,8 @@
 /* Allocate an array of NMEMB elements each SIZE bytes long.
    The entire array is initialized to zeros.  */
 __ptr_t
-calloc (nmemb, size)
-     register __malloc_size_t nmemb;
-     register __malloc_size_t size;
+calloc (register __malloc_size_t nmemb,
+        register __malloc_size_t size)
 {
   register __ptr_t result = malloc (nmemb * size);

@@ -1719,8 +1700,7 @@
    and return the start of data space, or NULL on errors.
    If INCREMENT is negative, shrink data space.  */
 __ptr_t
-__default_morecore (increment)
-     __malloc_ptrdiff_t increment;
+__default_morecore (__malloc_ptrdiff_t increment)
 {
   __ptr_t result;
 #if defined(CYGWIN)
@@ -1760,9 +1740,8 @@
 				__malloc_size_t __alignment));

 __ptr_t
-memalign (alignment, size)
-     __malloc_size_t alignment;
-     __malloc_size_t size;
+memalign (__malloc_size_t alignment,
+          __malloc_size_t size)
 {
   __ptr_t result;
   unsigned long int adj, lastadj;
@@ -1843,10 +1822,9 @@
 #endif

 int
-posix_memalign (memptr, alignment, size)
-     __ptr_t *memptr;
-     __malloc_size_t alignment;
-     __malloc_size_t size;
+posix_memalign (__ptr_t *memptr,
+                __malloc_size_t alignment,
+                __malloc_size_t size)
 {
   __ptr_t mem;

@@ -1917,8 +1895,7 @@
 static __malloc_size_t pagesize;

 __ptr_t
-valloc (size)
-     __malloc_size_t size;
+valloc (__malloc_size_t size)
 {
   if (pagesize == 0)
     pagesize = __getpagesize ();
@@ -2001,8 +1978,7 @@

 static enum mcheck_status checkhdr (const struct hdr *);
 static enum mcheck_status
-checkhdr (hdr)
-     const struct hdr *hdr;
+checkhdr (const struct hdr *hdr)
 {
   enum mcheck_status status;
   switch (hdr->magic)
@@ -2025,10 +2001,8 @@
   return status;
 }

-static void freehook (__ptr_t);
 static void
-freehook (ptr)
-     __ptr_t ptr;
+freehook (__ptr_t ptr)
 {
   struct hdr *hdr;

@@ -2047,10 +2021,8 @@
   __free_hook = freehook;
 }

-static __ptr_t mallochook (__malloc_size_t);
 static __ptr_t
-mallochook (size)
-     __malloc_size_t size;
+mallochook (__malloc_size_t size)
 {
   struct hdr *hdr;

@@ -2067,11 +2039,9 @@
   return (__ptr_t) (hdr + 1);
 }

-static __ptr_t reallochook (__ptr_t, __malloc_size_t);
 static __ptr_t
-reallochook (ptr, size)
-     __ptr_t ptr;
-     __malloc_size_t size;
+reallochook (__ptr_t ptr,
+             __malloc_size_t size)
 {
   struct hdr *hdr = NULL;
   __malloc_size_t osize = 0;
@@ -2105,8 +2075,7 @@
 }

 static void
-mabort (status)
-     enum mcheck_status status;
+mabort (enum mcheck_status status)
 {
   const char *msg;
   switch (status)
@@ -2139,8 +2108,7 @@
 static int mcheck_used = 0;

 int
-mcheck (func)
-     void (*func) (enum mcheck_status);
+mcheck (void (*func) (enum mcheck_status))
 {
   abortfunc = (func != NULL) ? func : &mabort;




[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 258 bytes --]

bug#9119: [PATCH] modernize function definitions in gmalloc.c

[Glenn Morris]

IIRC, traditionally this file has been left alone as much as possible,
so that it does not diverge from the glibc version (although it probably
has). I don't know if this is still the case. Ref eg

http://lists.gnu.org/archive/html/emacs-devel/2003-01/msg00247.html

Also apparently not appropriate for gnulib:

http://lists.gnu.org/archive/html/bug-gnulib/2010-10/msg00268.html

bug#9119: [PATCH] modernize function definitions in gmalloc.c

[Andreas Schwab]

Glenn Morris <rgm@gnu.org> writes:

> IIRC, traditionally this file has been left alone as much as possible,
> so that it does not diverge from the glibc version (although it probably
> has).

The contents of this file have been removed from glibc nearly 15 years
ago.

Andreas.

-- 
Andreas Schwab, schwab@linux-m68k.org
GPG Key fingerprint = 58CA 54C7 6D53 942B 1756  01D3 44D5 214B 8276 4ED5
"And now for something completely different."

bug#9119: [PATCH] modernize function definitions in gmalloc.c

[Lars Magne Ingebrigtsen]

Andreas Schwab <schwab@linux-m68k.org> writes:

>> IIRC, traditionally this file has been left alone as much as possible,
>> so that it does not diverge from the glibc version (although it probably
>> has).
>
> The contents of this file have been removed from glibc nearly 15 years
> ago.

So would it be OK to apply this patch, then?

-- 
(domestic pets only, the antidote for overdose, milk.)
  bloggy blog http://lars.ingebrigtsen.no/

bug#9119: [PATCH] modernize function definitions in gmalloc.c

[Eli Zaretskii]

> From: Lars Magne Ingebrigtsen <larsi@gnus.org>
> Date: Thu, 12 Apr 2012 21:42:15 +0200
> MailScanner-NULL-Check: 1334864536.4355@naLKYcv0obmsenG/4Sd/Qg
> Cc: 9119@debbugs.gnu.org, Daniel Colascione <dan.colascione@gmail.com>
> 
> Andreas Schwab <schwab@linux-m68k.org> writes:
> 
> >> IIRC, traditionally this file has been left alone as much as possible,
> >> so that it does not diverge from the glibc version (although it probably
> >> has).
> >
> > The contents of this file have been removed from glibc nearly 15 years
> > ago.
> 
> So would it be OK to apply this patch, then?

Yes, please.

bug#9119: [PATCH] modernize function definitions in gmalloc.c

[Lars Ingebrigtsen]

Eli Zaretskii <eliz@gnu.org> writes:

>> So would it be OK to apply this patch, then?
>
> Yes, please.

For some reason or other, patch won't accept the, er, patch:

patch: **** malformed patch at line 19: === modified file 'src/gmalloc.c'

I can't really see anything wrong with the patch by eyeballing it,
though.  Odd.

Dan, could you resend the patch as an attachment, by any chance?

-- 
(domestic pets only, the antidote for overdose, milk.)
  http://lars.ingebrigtsen.no  *  Sent from my Rome

bug#9119: [PATCH] modernize function definitions in gmalloc.c

[Andreas Schwab]

Lars Ingebrigtsen <larsi@gnus.org> writes:

> Eli Zaretskii <eliz@gnu.org> writes:
>
>>> So would it be OK to apply this patch, then?
>>
>> Yes, please.
>
> For some reason or other, patch won't accept the, er, patch:
>
> patch: **** malformed patch at line 19: === modified file 'src/gmalloc.c'
>
> I can't really see anything wrong with the patch by eyeballing it,
> though.  Odd.

The first hunk is obviously broken.  It claims to add two lines but adds
only one.

Andreas.

-- 
Andreas Schwab, schwab@linux-m68k.org
GPG Key fingerprint = 58CA 54C7 6D53 942B 1756  01D3 44D5 214B 8276 4ED5
"And now for something completely different."

bug#9119: [PATCH] modernize function definitions in gmalloc.c

[Ken Brown]

On 4/13/2012 5:43 PM, Andreas Schwab wrote:
> Lars Ingebrigtsen<larsi@gnus.org>  writes:
>
>> Eli Zaretskii<eliz@gnu.org>  writes:
>>
>>>> So would it be OK to apply this patch, then?
>>>
>>> Yes, please.
>>
>> For some reason or other, patch won't accept the, er, patch:
>>
>> patch: **** malformed patch at line 19: === modified file 'src/gmalloc.c'
>>
>> I can't really see anything wrong with the patch by eyeballing it,
>> though.  Odd.
>
> The first hunk is obviously broken.  It claims to add two lines but adds
> only one.

A more recent version of the patch was submitted in

   http://lists.gnu.org/archive/html/emacs-devel/2011-12/msg00609.html

with improvements by Paul and me.  Maybe that should be applied instead.

Ken

bug#9119: [PATCH] modernize function definitions in gmalloc.c

[Ken Brown]

On 4/13/2012 6:35 PM, Ken Brown wrote:
> On 4/13/2012 5:43 PM, Andreas Schwab wrote:
>> Lars Ingebrigtsen<larsi@gnus.org> writes:
>>
>>> Eli Zaretskii<eliz@gnu.org> writes:
>>>
>>>>> So would it be OK to apply this patch, then?
>>>>
>>>> Yes, please.
>>>
>>> For some reason or other, patch won't accept the, er, patch:
>>>
>>> patch: **** malformed patch at line 19: === modified file
>>> 'src/gmalloc.c'
>>>
>>> I can't really see anything wrong with the patch by eyeballing it,
>>> though. Odd.
>>
>> The first hunk is obviously broken. It claims to add two lines but adds
>> only one.
>
> A more recent version of the patch was submitted in
>
> http://lists.gnu.org/archive/html/emacs-devel/2011-12/msg00609.html
>
> with improvements by Paul and me. Maybe that should be applied instead.

Sorry, what I wrote was unclear.  The patch I just cited isn't really a 
more recent version of the one being discussed, but (with the 
improvements by Paul and me) supersedes the latter.

Ken

bug#9119: [PATCH] modernize function definitions in gmalloc.c

[Eli Zaretskii]

> Date: Fri, 13 Apr 2012 18:42:15 -0400
> From: Ken Brown <kbrown@cornell.edu>
> Cc: Lars Ingebrigtsen <larsi@gnus.org>, dan.colascione@gmail.com,
> 	9119@debbugs.gnu.org
> 
> > A more recent version of the patch was submitted in
> >
> > http://lists.gnu.org/archive/html/emacs-devel/2011-12/msg00609.html
> >
> > with improvements by Paul and me. Maybe that should be applied instead.
> 
> Sorry, what I wrote was unclear.  The patch I just cited isn't really a 
> more recent version of the one being discussed, but (with the 
> improvements by Paul and me) supersedes the latter.

Are you sure you got the URL right?  Perhaps you meant one of the 2
below instead?

  http://lists.gnu.org/archive/html/emacs-devel/2011-12/msg00716.html
  http://lists.gnu.org/archive/html/emacs-devel/2011-12/msg00720.html

bug#9119: [PATCH] modernize function definitions in gmalloc.c

[Ken Brown]

On 4/14/2012 3:07 AM, Eli Zaretskii wrote:
>> Date: Fri, 13 Apr 2012 18:42:15 -0400
>> From: Ken Brown<kbrown@cornell.edu>
>> Cc: Lars Ingebrigtsen<larsi@gnus.org>, dan.colascione@gmail.com,
>> 	9119@debbugs.gnu.org
>>
>>> A more recent version of the patch was submitted in
>>>
>>> http://lists.gnu.org/archive/html/emacs-devel/2011-12/msg00609.html
>>>
>>> with improvements by Paul and me. Maybe that should be applied instead.
>>
>> Sorry, what I wrote was unclear.  The patch I just cited isn't really a
>> more recent version of the one being discussed, but (with the
>> improvements by Paul and me) supersedes the latter.
>
> Are you sure you got the URL right?  Perhaps you meant one of the 2
> below instead?
>
>    http://lists.gnu.org/archive/html/emacs-devel/2011-12/msg00716.html
>    http://lists.gnu.org/archive/html/emacs-devel/2011-12/msg00720.html

I was just giving the URL of the beginning of the thread.  The URLs you 
cited contain the improvements by Paul and me that I referred to.  I 
should have said that.

The most recent version of the patch is in

   http://lists.gnu.org/archive/html/emacs-devel/2011-12/msg00720.html

in which Paul says, "And there's more where this came from -- that code 
is pretty crufty...."

So I don't know if that patch should just be applied now or if Paul 
plans to do more cleanup.

Ken

bug#9119: [PATCH] modernize function definitions in gmalloc.c

[Lars Ingebrigtsen]

Ken Brown <kbrown@cornell.edu> writes:

> The most recent version of the patch is in
>
>   http://lists.gnu.org/archive/html/emacs-devel/2011-12/msg00720.html
>
> in which Paul says, "And there's more where this came from -- that
> code is pretty crufty...."

And again, patch complains about this, too, being invalid:

patching file src/gmalloc.c
patch: **** malformed patch at line 145: @@ -473,9 +444,8 @@

Perhaps Paul can just apply his changes directly...

-- 
(domestic pets only, the antidote for overdose, milk.)
  http://lars.ingebrigtsen.no  *  Sent from my Rome

bug#9119: [PATCH] modernize function definitions in gmalloc.c

[Chong Yidong]

Lars Ingebrigtsen <larsi@gnus.org> writes:

> And again, patch complains about this, too, being invalid:
>
> patching file src/gmalloc.c
> patch: **** malformed patch at line 145: @@ -473,9 +444,8 @@

How the heck does that happen anyway?

bug#9119: [PATCH] modernize function definitions in gmalloc.c

[Eli Zaretskii]

> From: Chong Yidong <cyd@gnu.org>
> Date: Sat, 14 Apr 2012 21:38:56 +0800
> Cc: schwab@linux-m68k.org, 9119@debbugs.gnu.org,
> 	Paul Eggert <eggert@cs.ucla.edu>, dan.colascione@gmail.com
> 
> Lars Ingebrigtsen <larsi@gnus.org> writes:
> 
> > And again, patch complains about this, too, being invalid:
> >
> > patching file src/gmalloc.c
> > patch: **** malformed patch at line 145: @@ -473,9 +444,8 @@
> 
> How the heck does that happen anyway?

Manual editing of the diffs?

bug#9119: [PATCH] modernize function definitions in gmalloc.c

[Paul Eggert]

[-- Attachment #1: Type: text/plain, Size: 742 bytes --]

On 04/14/2012 04:21 AM, Lars Ingebrigtsen wrote:
> Perhaps Paul can just apply his changes directly...

I installed the non-tricky parts into the trunk,
in bzrs 107916 through 107919.
The gmalloc.c part remains.  Attached is a more up-to-date
version of the remaining part, with some more stuff added
that we've already talked about (e.g., replacing __malloc_size_t
with size_t) and some of the iffier stuff removed
(e.g., removing valloc).

I'd like to test it a bit more internally, before
installing it on the trunk.  The testing is a bit
tricky since the current Emacs trunk fails the
GC_MALLOC_CHECK tests on a "make bootstrap" when
using gmalloc.c.  I don't know if that is a longstanding
problem that can't easily be fixed, or what...

[-- Attachment #2: gmalloc-diff.txt --]
[-- Type: text/plain, Size: 42554 bytes --]

gmalloc.c modernization / cleanup (Bug#9119)
* gmalloc.c (_MALLOC_INTERNAL, _MALLOC_H, PP, __ptr_t)
(__malloc_size_t, __malloc_ptrdiff_t): Remove.
All uses removed and replaced by definiens as needed.
Also, it's now assumed that 'emacs' is defined.
Include <stdint.h>, for PTRDIFF_MAX.
(valloc): Declare only if not elided.
(r_alloc, r_alloc_free, r_re_alloc): Remove decls; no longer needed.
(protect_malloc_state, align, get_contiguous_space):
(malloc_atfork_handler_prepare, malloc_atfork_handler_parent)
(malloc_atfork_handler_child, malloc_enable_thread):
(malloc_initialize_1, __malloc_initialize, morecore_nolock):
(_malloc_internal_nolock, _malloc_internal, malloc, _malloc, _free)
(_realloc, _free_internal_nolock, _free_internal, free, cfree)
(special_realloc, _realloc_internal_nolock, _realloc_internal)
(realloc, calloc, __default_morecore, memalign, posix_memalign)
(valloc, checkhdr, freehook, mallochook, reallochook, mabort, mcheck)
(mprobe):
Use prototypes rather than old-style defns.  Omit no-longer-needed
decls with PP.
(align): Don't assume wraparound behavior after signed overflow.
(align, _malloc_internal_nolock, _free_internal_nolock, memalign):
Don't unsigned long int is wide enough to hold a pointer;
use uintptr_t instead.
(align): Omit set-but-never-used local var.
(malloc_initialize_1, morecore_nolock, _malloc_internal_nolock)
(_free_internal_nolock, memalign, mallochook, reallochook):
Omit no-longer-needed casts.
(_malloc, _free, _realloc): Add extern decls, to pacify GCC.
(_free_internal_nolock, _realloc_internal_nolock):
Add cast for non-GCC case.
(getpagesize): Do not assume unistd.h declares __getpagesize.
(MAGICWORD, MAGICFREE): Do not assume magic number is 32-bit.
(struct header.magic): Now size_t, not unsigned long int.
=== modified file 'src/gmalloc.c'
--- src/gmalloc.c	2011-09-09 01:06:52 +0000
+++ src/gmalloc.c	2012-04-16 07:04:23 +0000
@@ -1,9 +1,3 @@
-/* This file is no longer automatically generated from libc.  */
-
-#define _MALLOC_INTERNAL
-
-/* The malloc headers and source files from the C library follow here.  */
-
 /* Declarations for `malloc' and friends.
    Copyright (C) 1990, 1991, 1992, 1993, 1995, 1996, 1999, 2002, 2003, 2004,
                  2005, 2006, 2007 Free Software Foundation, Inc.
@@ -27,12 +21,6 @@
    The author may be reached (Email) at the address mike@ai.mit.edu,
    or (US mail) as Mike Haertel c/o Free Software Foundation.  */

-#ifndef _MALLOC_H
-
-#define _MALLOC_H	1
-
-#ifdef _MALLOC_INTERNAL
-
 #ifdef	HAVE_CONFIG_H
 #include <config.h>
 #endif
@@ -41,62 +29,44 @@
 #define USE_PTHREAD
 #endif

-#undef	PP
-#define	PP(args)	args
-#undef	__ptr_t
-#define	__ptr_t		void *
-
 #include <string.h>
 #include <limits.h>
+#include <stdint.h>
 #include <unistd.h>

 #ifdef USE_PTHREAD
 #include <pthread.h>
 #endif

-#endif	/* _MALLOC_INTERNAL.  */
-
-
 #ifdef	__cplusplus
 extern "C"
 {
 #endif

 #include <stddef.h>
-#define	__malloc_size_t		size_t
-#define	__malloc_ptrdiff_t	ptrdiff_t


 /* Allocate SIZE bytes of memory.  */
-extern __ptr_t malloc PP ((__malloc_size_t __size));
+extern void *malloc (size_t size);
 /* Re-allocate the previously allocated block
-   in __ptr_t, making the new block SIZE bytes long.  */
-extern __ptr_t realloc PP ((__ptr_t __ptr, __malloc_size_t __size));
+   in ptr, making the new block SIZE bytes long.  */
+extern void *realloc (void *ptr, size_t size);
 /* Allocate NMEMB elements of SIZE bytes each, all initialized to 0.  */
-extern __ptr_t calloc PP ((__malloc_size_t __nmemb, __malloc_size_t __size));
+extern void *calloc (size_t nmemb, size_t size);
 /* Free a block allocated by `malloc', `realloc' or `calloc'.  */
-extern void free PP ((__ptr_t __ptr));
+extern void free (void *ptr);

 /* Allocate SIZE bytes allocated to ALIGNMENT bytes.  */
-#if !defined (_MALLOC_INTERNAL) || defined (MSDOS) /* 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.  */
-#if ! (defined (_MALLOC_INTERNAL) && defined (GMALLOC_INHIBIT_VALLOC))
-extern __ptr_t valloc PP ((__malloc_size_t __size));
+#ifndef MSDOS
+extern void *memalign (size_t, size_t);
+extern int posix_memalign (void **, size_t, size_t);
 #endif

 #ifdef USE_PTHREAD
 /* Set up mutexes and make malloc etc. thread-safe.  */
-extern void malloc_enable_thread PP ((void));
+extern void malloc_enable_thread (void);
 #endif

-#ifdef _MALLOC_INTERNAL
-
 /* The allocator divides the heap into blocks of fixed size; large
    requests receive one or more whole blocks, and small requests
    receive a fragment of a block.  Fragment sizes are powers of two,
@@ -128,22 +98,22 @@
 	  {
 	    struct
 	      {
-		__malloc_size_t nfree; /* Free frags in a fragmented block.  */
-		__malloc_size_t first; /* First free fragment of the block.  */
+		size_t nfree; /* Free frags in a fragmented block.  */
+		size_t first; /* First free fragment of the block.  */
 	      } frag;
 	    /* For a large object, in its first block, this has the number
 	       of blocks in the object.  In the other blocks, this has a
 	       negative number which says how far back the first block is.  */
-	    __malloc_ptrdiff_t size;
+	    ptrdiff_t size;
 	  } info;
       } busy;
     /* Heap information for a free block
        (that may be the first of a free cluster).  */
     struct
       {
-	__malloc_size_t size;	/* Size (in blocks) of a free cluster.  */
-	__malloc_size_t next;	/* Index of next free cluster.  */
-	__malloc_size_t prev;	/* Index of previous free cluster.  */
+	size_t size;	/* Size (in blocks) of a free cluster.  */
+	size_t next;	/* Index of next free cluster.  */
+	size_t prev;	/* Index of previous free cluster.  */
       } free;
   } malloc_info;

@@ -155,13 +125,13 @@

 /* Address to block number and vice versa.  */
 #define BLOCK(A)	(((char *) (A) - _heapbase) / BLOCKSIZE + 1)
-#define ADDRESS(B)	((__ptr_t) (((B) - 1) * BLOCKSIZE + _heapbase))
+#define ADDRESS(B)	((void *) (((B) - 1) * BLOCKSIZE + _heapbase))

 /* Current search index for the heap table.  */
-extern __malloc_size_t _heapindex;
+extern size_t _heapindex;

 /* Limit of valid info table indices.  */
-extern __malloc_size_t _heaplimit;
+extern size_t _heaplimit;

 /* Doubly linked lists of free fragments.  */
 struct list
@@ -177,26 +147,26 @@
 struct alignlist
   {
     struct alignlist *next;
-    __ptr_t aligned;		/* The address that memaligned returned.  */
-    __ptr_t exact;		/* The address that malloc returned.  */
+    void *aligned;		/* The address that memaligned returned.  */
+    void *exact;		/* The address that malloc returned.  */
   };
 extern struct alignlist *_aligned_blocks;

 /* Instrumentation.  */
-extern __malloc_size_t _chunks_used;
-extern __malloc_size_t _bytes_used;
-extern __malloc_size_t _chunks_free;
-extern __malloc_size_t _bytes_free;
+extern size_t _chunks_used;
+extern size_t _bytes_used;
+extern size_t _chunks_free;
+extern size_t _bytes_free;

 /* Internal versions of `malloc', `realloc', and `free'
    used when these functions need to call each other.
    They are the same but don't call the hooks.  */
-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));
+extern void *_malloc_internal (size_t);
+extern void *_realloc_internal (void *, size_t);
+extern void _free_internal (void *);
+extern void *_malloc_internal_nolock (size_t);
+extern void *_realloc_internal_nolock (void *, size_t);
+extern void _free_internal_nolock (void *);

 #ifdef USE_PTHREAD
 extern pthread_mutex_t _malloc_mutex, _aligned_blocks_mutex;
@@ -228,39 +198,36 @@
 #define UNLOCK_ALIGNED_BLOCKS()
 #endif

-#endif /* _MALLOC_INTERNAL.  */
-
 /* Given an address in the middle of a malloc'd object,
    return the address of the beginning of the object.  */
-extern __ptr_t malloc_find_object_address PP ((__ptr_t __ptr));
+extern void *malloc_find_object_address (void *ptr);

 /* Underlying allocation function; successive calls should
    return contiguous pieces of memory.  */
-extern __ptr_t (*__morecore) PP ((__malloc_ptrdiff_t __size));
+extern void *(*__morecore) (ptrdiff_t size);

 /* Default value of `__morecore'.  */
-extern __ptr_t __default_morecore PP ((__malloc_ptrdiff_t __size));
+extern void *__default_morecore (ptrdiff_t size);

 /* If not NULL, this function is called after each time
    `__morecore' is called to increase the data size.  */
-extern void (*__after_morecore_hook) PP ((void));
+extern void (*__after_morecore_hook) (void);

 /* Number of extra blocks to get each time we ask for more core.
    This reduces the frequency of calling `(*__morecore)'.  */
-extern __malloc_size_t __malloc_extra_blocks;
+extern size_t __malloc_extra_blocks;

 /* Nonzero if `malloc' has been called and done its initialization.  */
 extern int __malloc_initialized;
 /* Function called to initialize malloc data structures.  */
-extern int __malloc_initialize PP ((void));
+extern int __malloc_initialize (void);

 /* Hooks for debugging versions.  */
-extern void (*__malloc_initialize_hook) PP ((void));
-extern void (*__free_hook) PP ((__ptr_t __ptr));
-extern __ptr_t (*__malloc_hook) PP ((__malloc_size_t __size));
-extern __ptr_t (*__realloc_hook) PP ((__ptr_t __ptr, __malloc_size_t __size));
-extern __ptr_t (*__memalign_hook) PP ((__malloc_size_t __size,
-				       __malloc_size_t __alignment));
+extern void (*__malloc_initialize_hook) (void);
+extern void (*__free_hook) (void *ptr);
+extern void *(*__malloc_hook) (size_t size);
+extern void *(*__realloc_hook) (void *ptr, size_t size);
+extern void *(*__memalign_hook) (size_t size, size_t alignment);

 /* Return values for `mprobe': these are the kinds of inconsistencies that
    `mcheck' enables detection of.  */
@@ -277,52 +244,37 @@
    before `malloc' is ever called.  ABORTFUNC is called with an error code
    (see enum above) when an inconsistency is detected.  If ABORTFUNC is
    null, the standard function prints on stderr and then calls `abort'.  */
-extern int mcheck PP ((void (*__abortfunc) PP ((enum mcheck_status))));
+extern int mcheck (void (*abortfunc) (enum mcheck_status));

 /* Check for aberrations in a particular malloc'd block.  You must have
    called `mcheck' already.  These are the same checks that `mcheck' does
    when you free or reallocate a block.  */
-extern enum mcheck_status mprobe PP ((__ptr_t __ptr));
+extern enum mcheck_status mprobe (void *ptr);

 /* Activate a standard collection of tracing hooks.  */
-extern void mtrace PP ((void));
-extern void muntrace PP ((void));
+extern void mtrace (void);
+extern void muntrace (void);

 /* Statistics available to the user.  */
 struct mstats
   {
-    __malloc_size_t bytes_total; /* Total size of the heap. */
-    __malloc_size_t chunks_used; /* Chunks allocated by the user. */
-    __malloc_size_t bytes_used;	/* Byte total of user-allocated chunks. */
-    __malloc_size_t chunks_free; /* Chunks in the free list. */
-    __malloc_size_t bytes_free;	/* Byte total of chunks in the free list. */
+    size_t bytes_total;	/* Total size of the heap. */
+    size_t chunks_used;	/* Chunks allocated by the user. */
+    size_t bytes_used;	/* Byte total of user-allocated chunks. */
+    size_t chunks_free;	/* Chunks in the free list. */
+    size_t bytes_free;	/* Byte total of chunks in the free list. */
   };

 /* Pick up the current statistics. */
-extern struct mstats mstats PP ((void));
+extern struct mstats mstats (void);

 /* Call WARNFUN with a warning message when memory usage is high.  */
-extern void memory_warnings PP ((__ptr_t __start,
-				 void (*__warnfun) PP ((const char *))));
-
-
-/* Relocating allocator.  */
-
-/* Allocate SIZE bytes, and store the address in *HANDLEPTR.  */
-extern __ptr_t r_alloc PP ((__ptr_t *__handleptr, __malloc_size_t __size));
-
-/* Free the storage allocated in HANDLEPTR.  */
-extern void r_alloc_free PP ((__ptr_t *__handleptr));
-
-/* Adjust the block at HANDLEPTR to be SIZE bytes long.  */
-extern __ptr_t r_re_alloc PP ((__ptr_t *__handleptr, __malloc_size_t __size));
-
+extern void memory_warnings (void *start, void (*warnfun) (const char *));

 #ifdef	__cplusplus
 }
 #endif

-#endif /* malloc.h  */
 /* Memory allocator `malloc'.
    Copyright 1990, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
 		  Written May 1989 by Mike Haertel.
@@ -345,10 +297,6 @@
    The author may be reached (Email) at the address mike@ai.mit.edu,
    or (US mail) as Mike Haertel c/o Free Software Foundation.  */

-#ifndef	_MALLOC_INTERNAL
-#define _MALLOC_INTERNAL
-#include <malloc.h>
-#endif
 #include <errno.h>

 /* On Cygwin there are two heaps.  temacs uses the static heap
@@ -362,15 +310,15 @@
    this is changed in the future, we'll have to similarly deal with
    reinitializing ralloc. */
 #ifdef CYGWIN
-extern __ptr_t bss_sbrk PP ((ptrdiff_t __size));
+extern void *bss_sbrk (ptrdiff_t size);
 extern int bss_sbrk_did_unexec;
 char *bss_sbrk_heapbase;	/* _heapbase for static heap */
 malloc_info *bss_sbrk_heapinfo;	/* _heapinfo for static heap */
 #endif
-__ptr_t (*__morecore) PP ((__malloc_ptrdiff_t __size)) = __default_morecore;
+void *(*__morecore) (ptrdiff_t size) = __default_morecore;

 /* Debugging hook for `malloc'.  */
-__ptr_t (*__malloc_hook) PP ((__malloc_size_t __size));
+void *(*__malloc_hook) (size_t size);

 /* Pointer to the base of the first block.  */
 char *_heapbase;
@@ -379,30 +327,30 @@
 malloc_info *_heapinfo;

 /* Number of info entries.  */
-static __malloc_size_t heapsize;
+static size_t heapsize;

 /* Search index in the info table.  */
-__malloc_size_t _heapindex;
+size_t _heapindex;

 /* Limit of valid info table indices.  */
-__malloc_size_t _heaplimit;
+size_t _heaplimit;

 /* Free lists for each fragment size.  */
 struct list _fraghead[BLOCKLOG];

 /* Instrumentation.  */
-__malloc_size_t _chunks_used;
-__malloc_size_t _bytes_used;
-__malloc_size_t _chunks_free;
-__malloc_size_t _bytes_free;
+size_t _chunks_used;
+size_t _bytes_used;
+size_t _chunks_free;
+size_t _bytes_free;

 /* Are you experienced?  */
 int __malloc_initialized;

-__malloc_size_t __malloc_extra_blocks;
+size_t __malloc_extra_blocks;

-void (*__malloc_initialize_hook) PP ((void));
-void (*__after_morecore_hook) PP ((void));
+void (*__malloc_initialize_hook) (void);
+void (*__after_morecore_hook) (void);

 #if defined GC_MALLOC_CHECK && defined GC_PROTECT_MALLOC_STATE

@@ -419,12 +367,11 @@
 #include <sys/mman.h>

 static int state_protected_p;
-static __malloc_size_t last_state_size;
+static size_t last_state_size;
 static malloc_info *last_heapinfo;

 void
-protect_malloc_state (protect_p)
-     int protect_p;
+protect_malloc_state (int protect_p)
 {
   /* If _heapinfo has been relocated, make sure its old location
      isn't left read-only; it will be reused by malloc.  */
@@ -453,29 +400,25 @@


 /* Aligned allocation.  */
-static __ptr_t align PP ((__malloc_size_t));
-static __ptr_t
-align (size)
-     __malloc_size_t size;
+static void *
+align (size_t size)
 {
-  __ptr_t result;
-  unsigned long int adj;
+  void *result;
+  ptrdiff_t adj;

   /* align accepts an unsigned argument, but __morecore accepts a
-     signed one.  This could lead to trouble if SIZE overflows a
-     signed int type accepted by __morecore.  We just punt in that
+     signed one.  This could lead to trouble if SIZE overflows the
+     ptrdiff_t type accepted by __morecore.  We just punt in that
      case, since they are requesting a ludicrous amount anyway.  */
-  if ((__malloc_ptrdiff_t)size < 0)
+  if (PTRDIFF_MAX < size)
     result = 0;
   else
     result = (*__morecore) (size);
-  adj = (unsigned long int) ((unsigned long int) ((char *) result -
-						  (char *) NULL)) % BLOCKSIZE;
+  adj = (uintptr_t) result % BLOCKSIZE;
   if (adj != 0)
     {
-      __ptr_t new;
       adj = BLOCKSIZE - adj;
-      new = (*__morecore) (adj);
+      (*__morecore) (adj);
       result = (char *) result + adj;
     }

@@ -488,14 +431,11 @@
 /* Get SIZE bytes, if we can get them starting at END.
    Return the address of the space we got.
    If we cannot get space at END, fail and return 0.  */
-static __ptr_t get_contiguous_space PP ((__malloc_ptrdiff_t, __ptr_t));
-static __ptr_t
-get_contiguous_space (size, position)
-     __malloc_ptrdiff_t size;
-     __ptr_t position;
+static void *
+get_contiguous_space (ptrdiff_t size, void *position)
 {
-  __ptr_t before;
-  __ptr_t after;
+  void *before;
+  void *after;

   before = (*__morecore) (0);
   /* If we can tell in advance that the break is at the wrong place,
@@ -525,7 +465,7 @@
 static inline void
 register_heapinfo (void)
 {
-  __malloc_size_t block, blocks;
+  size_t block, blocks;

   block = BLOCK (_heapinfo);
   blocks = BLOCKIFY (heapsize * sizeof (malloc_info));
@@ -548,21 +488,21 @@
 int _malloc_thread_enabled_p;

 static void
-malloc_atfork_handler_prepare ()
+malloc_atfork_handler_prepare (void)
 {
   LOCK ();
   LOCK_ALIGNED_BLOCKS ();
 }

 static void
-malloc_atfork_handler_parent ()
+malloc_atfork_handler_parent (void)
 {
   UNLOCK_ALIGNED_BLOCKS ();
   UNLOCK ();
 }

 static void
-malloc_atfork_handler_child ()
+malloc_atfork_handler_child (void)
 {
   UNLOCK_ALIGNED_BLOCKS ();
   UNLOCK ();
@@ -570,7 +510,7 @@

 /* Set up mutexes and make malloc etc. thread-safe.  */
 void
-malloc_enable_thread ()
+malloc_enable_thread (void)
 {
   if (_malloc_thread_enabled_p)
     return;
@@ -589,7 +529,7 @@
 #endif

 static void
-malloc_initialize_1 ()
+malloc_initialize_1 (void)
 {
 #ifdef GC_MCHECK
   mcheck (NULL);
@@ -609,7 +549,7 @@
     (*__malloc_initialize_hook) ();

   heapsize = HEAP / BLOCKSIZE;
-  _heapinfo = (malloc_info *) align (heapsize * sizeof (malloc_info));
+  _heapinfo = align (heapsize * sizeof (malloc_info));
   if (_heapinfo == NULL)
     return;
   memset (_heapinfo, 0, heapsize * sizeof (malloc_info));
@@ -630,7 +570,7 @@
    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 ()
+__malloc_initialize (void)
 {
   if (__malloc_initialized)
     return 0;
@@ -644,14 +584,12 @@

 /* Get neatly aligned memory, initializing or
    growing the heap info table as necessary. */
-static __ptr_t morecore_nolock PP ((__malloc_size_t));
-static __ptr_t
-morecore_nolock (size)
-     __malloc_size_t size;
+static void *
+morecore_nolock (size_t size)
 {
-  __ptr_t result;
+  void *result;
   malloc_info *newinfo, *oldinfo;
-  __malloc_size_t newsize;
+  size_t newsize;

   if (morecore_recursing)
     /* Avoid recursion.  The caller will know how to handle a null return.  */
@@ -664,7 +602,7 @@
   PROTECT_MALLOC_STATE (0);

   /* Check if we need to grow the info table.  */
-  if ((__malloc_size_t) BLOCK ((char *) result + size) > heapsize)
+  if ((size_t) BLOCK ((char *) result + size) > heapsize)
     {
       /* Calculate the new _heapinfo table size.  We do not account for the
 	 added blocks in the table itself, as we hope to place them in
@@ -673,7 +611,7 @@
       newsize = heapsize;
       do
 	newsize *= 2;
-      while ((__malloc_size_t) BLOCK ((char *) result + size) > newsize);
+      while ((size_t) BLOCK ((char *) result + size) > newsize);

       /* We must not reuse existing core for the new info table when called
 	 from realloc in the case of growing a large block, because the
@@ -689,8 +627,8 @@
 	     `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_nolock
-	    (_heapinfo, newsize * sizeof (malloc_info));
+	  newinfo = _realloc_internal_nolock (_heapinfo,
+					      newsize * sizeof (malloc_info));
 	  morecore_recursing = 0;
 	  if (newinfo == NULL)
 	    errno = save;
@@ -710,7 +648,7 @@
       /* Allocate new space for the malloc info table.  */
       while (1)
   	{
- 	  newinfo = (malloc_info *) align (newsize * sizeof (malloc_info));
+ 	  newinfo = align (newsize * sizeof (malloc_info));

  	  /* Did it fail?  */
  	  if (newinfo == NULL)
@@ -721,8 +659,8 @@

  	  /* Is it big enough to record status for its own space?
  	     If so, we win.  */
- 	  if ((__malloc_size_t) BLOCK ((char *) newinfo
- 				       + newsize * sizeof (malloc_info))
+ 	  if ((size_t) BLOCK ((char *) newinfo
+			      + newsize * sizeof (malloc_info))
  	      < newsize)
  	    break;

@@ -759,13 +697,12 @@
 }

 /* Allocate memory from the heap.  */
-__ptr_t
-_malloc_internal_nolock (size)
-     __malloc_size_t size;
+void *
+_malloc_internal_nolock (size_t size)
 {
-  __ptr_t result;
-  __malloc_size_t block, blocks, lastblocks, start;
-  register __malloc_size_t i;
+  void *result;
+  size_t block, blocks, lastblocks, start;
+  register size_t i;
   struct list *next;

   /* ANSI C allows `malloc (0)' to either return NULL, or to return a
@@ -790,7 +727,7 @@
     {
       /* Small allocation to receive a fragment of a block.
 	 Determine the logarithm to base two of the fragment size. */
-      register __malloc_size_t log = 1;
+      register size_t log = 1;
       --size;
       while ((size /= 2) != 0)
 	++log;
@@ -803,15 +740,14 @@
 	  /* There are free fragments of this size.
 	     Pop a fragment out of the fragment list and return it.
 	     Update the block's nfree and first counters. */
-	  result = (__ptr_t) next;
+	  result = next;
 	  next->prev->next = next->next;
 	  if (next->next != NULL)
 	    next->next->prev = next->prev;
 	  block = BLOCK (result);
 	  if (--_heapinfo[block].busy.info.frag.nfree != 0)
-	    _heapinfo[block].busy.info.frag.first = (unsigned long int)
-	      ((unsigned long int) ((char *) next->next - (char *) NULL)
-	       % BLOCKSIZE) >> log;
+	    _heapinfo[block].busy.info.frag.first =
+	      (uintptr_t) next->next % BLOCKSIZE >> log;

 	  /* Update the statistics.  */
 	  ++_chunks_used;
@@ -843,7 +779,7 @@
 	  next->prev = &_fraghead[log];
 	  _fraghead[log].next = next;

-	  for (i = 2; i < (__malloc_size_t) (BLOCKSIZE >> log); ++i)
+	  for (i = 2; i < (size_t) (BLOCKSIZE >> log); ++i)
 	    {
 	      next = (struct list *) ((char *) result + (i << log));
 	      next->next = _fraghead[log].next;
@@ -877,7 +813,7 @@
 	  if (block == start)
 	    {
 	      /* Need to get more from the system.  Get a little extra.  */
-	      __malloc_size_t wantblocks = blocks + __malloc_extra_blocks;
+	      size_t wantblocks = blocks + __malloc_extra_blocks;
 	      block = _heapinfo[0].free.prev;
 	      lastblocks = _heapinfo[block].free.size;
 	      /* Check to see if the new core will be contiguous with the
@@ -959,11 +895,10 @@
   return result;
 }

-__ptr_t
-_malloc_internal (size)
-     __malloc_size_t size;
+void *
+_malloc_internal (size_t size)
 {
-  __ptr_t result;
+  void *result;

   LOCK ();
   result = _malloc_internal_nolock (size);
@@ -972,11 +907,10 @@
   return result;
 }

-__ptr_t
-malloc (size)
-     __malloc_size_t size;
+void *
+malloc (size_t size)
 {
-  __ptr_t (*hook) (__malloc_size_t);
+  void *(*hook) (size_t);

   if (!__malloc_initialized && !__malloc_initialize ())
     return NULL;
@@ -998,24 +932,24 @@
 /* On some ANSI C systems, some libc functions call _malloc, _free
    and _realloc.  Make them use the GNU functions.  */

-__ptr_t
-_malloc (size)
-     __malloc_size_t size;
+extern void *_malloc (size_t);
+extern void _free (void *);
+extern void *_realloc (void *, size_t);
+
+void *
+_malloc (size_t size)
 {
   return malloc (size);
 }

 void
-_free (ptr)
-     __ptr_t ptr;
+_free (void *ptr)
 {
   free (ptr);
 }

-__ptr_t
-_realloc (ptr, size)
-     __ptr_t ptr;
-     __malloc_size_t size;
+void *
+_realloc (void *ptr, size_t size)
 {
   return realloc (ptr, size);
 }
@@ -1043,14 +977,9 @@
    The author may be reached (Email) at the address mike@ai.mit.edu,
    or (US mail) as Mike Haertel c/o Free Software Foundation.  */

-#ifndef	_MALLOC_INTERNAL
-#define _MALLOC_INTERNAL
-#include <malloc.h>
-#endif
-

 /* Debugging hook for free.  */
-void (*__free_hook) PP ((__ptr_t __ptr));
+void (*__free_hook) (void *__ptr);

 /* List of blocks allocated by memalign.  */
 struct alignlist *_aligned_blocks = NULL;
@@ -1058,15 +987,14 @@
 /* Return memory to the heap.
    Like `_free_internal' but don't lock mutex.  */
 void
-_free_internal_nolock (ptr)
-     __ptr_t ptr;
+_free_internal_nolock (void *ptr)
 {
   int type;
-  __malloc_size_t block, blocks;
-  register __malloc_size_t i;
+  size_t block, blocks;
+  register size_t i;
   struct list *prev, *next;
-  __ptr_t curbrk;
-  const __malloc_size_t lesscore_threshold
+  void *curbrk;
+  const size_t lesscore_threshold
     /* Threshold of free space at which we will return some to the system.  */
     = FINAL_FREE_BLOCKS + 2 * __malloc_extra_blocks;

@@ -1076,7 +1004,7 @@
     return;

 #ifdef CYGWIN
-  if (ptr < _heapbase)
+  if ((char *) ptr < _heapbase)
     /* We're being asked to free something in the static heap. */
     return;
 #endif
@@ -1162,12 +1090,12 @@
 	     It's possible that moving _heapinfo will allow us to
 	     return some space to the system.  */

- 	  __malloc_size_t info_block = BLOCK (_heapinfo);
- 	  __malloc_size_t info_blocks = _heapinfo[info_block].busy.info.size;
- 	  __malloc_size_t prev_block = _heapinfo[block].free.prev;
- 	  __malloc_size_t prev_blocks = _heapinfo[prev_block].free.size;
- 	  __malloc_size_t next_block = _heapinfo[block].free.next;
- 	  __malloc_size_t next_blocks = _heapinfo[next_block].free.size;
+ 	  size_t info_block = BLOCK (_heapinfo);
+ 	  size_t info_blocks = _heapinfo[info_block].busy.info.size;
+ 	  size_t prev_block = _heapinfo[block].free.prev;
+ 	  size_t prev_blocks = _heapinfo[prev_block].free.size;
+ 	  size_t next_block = _heapinfo[block].free.next;
+ 	  size_t next_blocks = _heapinfo[next_block].free.size;

 	  if (/* Win if this block being freed is last in core, the info table
 		 is just before it, the previous free block is just before the
@@ -1190,7 +1118,7 @@
 	      )
 	    {
 	      malloc_info *newinfo;
-	      __malloc_size_t oldlimit = _heaplimit;
+	      size_t oldlimit = _heaplimit;

 	      /* Free the old info table, clearing _heaplimit to avoid
 		 recursion into this code.  We don't want to return the
@@ -1205,8 +1133,7 @@
 	      _heapindex = 0;

 	      /* Allocate new space for the info table and move its data.  */
-	      newinfo = (malloc_info *) _malloc_internal_nolock (info_blocks
-								 * BLOCKSIZE);
+	      newinfo = _malloc_internal_nolock (info_blocks * BLOCKSIZE);
 	      PROTECT_MALLOC_STATE (0);
 	      memmove (newinfo, _heapinfo, info_blocks * BLOCKSIZE);
 	      _heapinfo = newinfo;
@@ -1222,7 +1149,7 @@
 	  /* Now see if we can return stuff to the system.  */
 	  if (block + blocks == _heaplimit && blocks >= lesscore_threshold)
 	    {
-	      register __malloc_size_t bytes = blocks * BLOCKSIZE;
+	      register size_t bytes = blocks * BLOCKSIZE;
 	      _heaplimit -= blocks;
 	      (*__morecore) (-bytes);
 	      _heapinfo[_heapinfo[block].free.prev].free.next
@@ -1255,7 +1182,7 @@
 	  /* If all fragments of this block are free, remove them
 	     from the fragment list and free the whole block.  */
 	  next = prev;
-	  for (i = 1; i < (__malloc_size_t) (BLOCKSIZE >> type); ++i)
+	  for (i = 1; i < (size_t) (BLOCKSIZE >> type); ++i)
 	    next = next->next;
 	  prev->prev->next = next;
 	  if (next != NULL)
@@ -1280,7 +1207,7 @@
 	  /* If some fragments of this block are free, link this
 	     fragment into the fragment list after the first free
 	     fragment of this block. */
-	  next = (struct list *) ptr;
+	  next = ptr;
 	  next->next = prev->next;
 	  next->prev = prev;
 	  prev->next = next;
@@ -1293,11 +1220,10 @@
 	  /* No fragments of this block are free, so link this
 	     fragment into the fragment list and announce that
 	     it is the first free fragment of this block. */
-	  prev = (struct list *) ptr;
+	  prev = ptr;
 	  _heapinfo[block].busy.info.frag.nfree = 1;
-	  _heapinfo[block].busy.info.frag.first = (unsigned long int)
-	    ((unsigned long int) ((char *) ptr - (char *) NULL)
-	     % BLOCKSIZE >> type);
+	  _heapinfo[block].busy.info.frag.first =
+	    (uintptr_t) ptr % BLOCKSIZE >> type;
 	  prev->next = _fraghead[type].next;
 	  prev->prev = &_fraghead[type];
 	  prev->prev->next = prev;
@@ -1313,8 +1239,7 @@
 /* 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;
+_free_internal (void *ptr)
 {
   LOCK ();
   _free_internal_nolock (ptr);
@@ -1324,10 +1249,9 @@
 /* Return memory to the heap.  */

 void
-free (ptr)
-     __ptr_t ptr;
+free (void *ptr)
 {
-  void (*hook) (__ptr_t) = __free_hook;
+  void (*hook) (void *) = __free_hook;

   if (hook != NULL)
     (*hook) (ptr);
@@ -1340,8 +1264,7 @@
 weak_alias (free, cfree)
 #else
 void
-cfree (ptr)
-     __ptr_t ptr;
+cfree (void *ptr)
 {
   free (ptr);
 }
@@ -1368,32 +1291,24 @@
    The author may be reached (Email) at the address mike@ai.mit.edu,
    or (US mail) as Mike Haertel c/o Free Software Foundation.  */

-#ifndef	_MALLOC_INTERNAL
-#define _MALLOC_INTERNAL
-#include <malloc.h>
-#endif
-
-
 #define min(A, B) ((A) < (B) ? (A) : (B))

 /* On Cygwin the dumped emacs may try to realloc storage allocated in
    the static heap.  We just malloc space in the new heap and copy the
    data.  */
 #ifdef CYGWIN
-__ptr_t
-special_realloc (ptr, size)
-     __ptr_t ptr;
-     __malloc_size_t size;
+void *
+special_realloc (void *ptr, size_t size)
 {
-  __ptr_t result;
+  void *result;
   int type;
-  __malloc_size_t block, oldsize;
+  size_t block, oldsize;

   block = ((char *) ptr - bss_sbrk_heapbase) / BLOCKSIZE + 1;
   type = bss_sbrk_heapinfo[block].busy.type;
   oldsize =
     type == 0 ? bss_sbrk_heapinfo[block].busy.info.size * BLOCKSIZE
-    : (__malloc_size_t) 1 << type;
+    : (size_t) 1 << type;
   result = _malloc_internal_nolock (size);
   if (result != NULL)
     memcpy (result, ptr, min (oldsize, size));
@@ -1402,7 +1317,7 @@
 #endif

 /* Debugging hook for realloc.  */
-__ptr_t (*__realloc_hook) PP ((__ptr_t __ptr, __malloc_size_t __size));
+void *(*__realloc_hook) (void *ptr, size_t size);

 /* Resize the given region to the new size, returning a pointer
    to the (possibly moved) region.  This is optimized for speed;
@@ -1410,14 +1325,12 @@
    achieved by unconditionally allocating and copying to a
    new region.  This module has incestuous knowledge of the
    internals of both free and malloc. */
-__ptr_t
-_realloc_internal_nolock (ptr, size)
-     __ptr_t ptr;
-     __malloc_size_t size;
+void *
+_realloc_internal_nolock (void *ptr, size_t size)
 {
-  __ptr_t result;
+  void *result;
   int type;
-  __malloc_size_t block, blocks, oldlimit;
+  size_t block, blocks, oldlimit;

   if (size == 0)
     {
@@ -1428,7 +1341,7 @@
     return _malloc_internal_nolock (size);

 #ifdef CYGWIN
-  if (ptr < _heapbase)
+  if ((char *) ptr < _heapbase)
     /* ptr points into the static heap */
     return special_realloc (ptr, size);
 #endif
@@ -1497,7 +1410,7 @@
 	        (void) _malloc_internal_nolock (blocks * BLOCKSIZE);
 	      else
 		{
-		  __ptr_t previous
+		  void *previous
 		    = _malloc_internal_nolock ((block - _heapindex) * BLOCKSIZE);
 		  (void) _malloc_internal_nolock (blocks * BLOCKSIZE);
 		  _free_internal_nolock (previous);
@@ -1512,8 +1425,8 @@
     default:
       /* Old size is a fragment; type is logarithm
 	 to base two of the fragment size.  */
-      if (size > (__malloc_size_t) (1 << (type - 1)) &&
-	  size <= (__malloc_size_t) (1 << type))
+      if (size > (size_t) (1 << (type - 1)) &&
+	  size <= (size_t) (1 << type))
 	/* The new size is the same kind of fragment.  */
 	result = ptr;
       else
@@ -1523,7 +1436,7 @@
 	  result = _malloc_internal_nolock (size);
 	  if (result == NULL)
 	    goto out;
-	  memcpy (result, ptr, min (size, (__malloc_size_t) 1 << type));
+	  memcpy (result, ptr, min (size, (size_t) 1 << type));
 	  _free_internal_nolock (ptr);
 	}
       break;
@@ -1534,12 +1447,10 @@
   return result;
 }

-__ptr_t
-_realloc_internal (ptr, size)
-     __ptr_t ptr;
-     __malloc_size_t size;
+void *
+_realloc_internal (void *ptr, size_t size)
 {
-  __ptr_t result;
+  void *result;

   LOCK ();
   result = _realloc_internal_nolock (ptr, size);
@@ -1548,12 +1459,10 @@
   return result;
 }

-__ptr_t
-realloc (ptr, size)
-     __ptr_t ptr;
-     __malloc_size_t size;
+void *
+realloc (void *ptr, size_t size)
 {
-  __ptr_t (*hook) (__ptr_t, __malloc_size_t);
+  void *(*hook) (void *, size_t);

   if (!__malloc_initialized && !__malloc_initialize ())
     return NULL;
@@ -1581,19 +1490,12 @@
    The author may be reached (Email) at the address mike@ai.mit.edu,
    or (US mail) as Mike Haertel c/o Free Software Foundation.  */

-#ifndef	_MALLOC_INTERNAL
-#define	_MALLOC_INTERNAL
-#include <malloc.h>
-#endif
-
 /* Allocate an array of NMEMB elements each SIZE bytes long.
    The entire array is initialized to zeros.  */
-__ptr_t
-calloc (nmemb, size)
-     register __malloc_size_t nmemb;
-     register __malloc_size_t size;
+void *
+calloc (register size_t nmemb, register size_t size)
 {
-  register __ptr_t result = malloc (nmemb * size);
+  register void *result = malloc (nmemb * size);

   if (result != NULL)
     (void) memset (result, 0, nmemb * size);
@@ -1618,11 +1520,6 @@
 the Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
 MA 02110-1301, USA.  */

-#ifndef	_MALLOC_INTERNAL
-#define	_MALLOC_INTERNAL
-#include <malloc.h>
-#endif
-
 /* uClibc defines __GNU_LIBRARY__, but it is not completely
    compatible.  */
 #if !defined (__GNU_LIBRARY__) || defined (__UCLIBC__)
@@ -1631,8 +1528,7 @@
 /* It is best not to declare this and cast its result on foreign operating
    systems with potentially hostile include files.  */

-#include <stddef.h>
-extern __ptr_t __sbrk PP ((ptrdiff_t increment));
+extern void *__sbrk (ptrdiff_t increment);
 #endif /* __GNU_LIBRARY__ && ! defined (__UCLIBC__) */

 #ifndef NULL
@@ -1642,19 +1538,18 @@
 /* Allocate INCREMENT more bytes of data space,
    and return the start of data space, or NULL on errors.
    If INCREMENT is negative, shrink data space.  */
-__ptr_t
-__default_morecore (increment)
-     __malloc_ptrdiff_t increment;
+void *
+__default_morecore (ptrdiff_t increment)
 {
-  __ptr_t result;
+  void *result;
 #if defined (CYGWIN)
   if (!bss_sbrk_did_unexec)
     {
       return bss_sbrk (increment);
     }
 #endif
-  result = (__ptr_t) __sbrk (increment);
-  if (result == (__ptr_t) -1)
+  result = (void *) __sbrk (increment);
+  if (result == (void *) -1)
     return NULL;
   return result;
 }
@@ -1675,22 +1570,14 @@
 not, write to the Free Software Foundation, Inc., 51 Franklin Street,
 Fifth Floor, Boston, MA 02110-1301, USA.  */

-#ifndef	_MALLOC_INTERNAL
-#define _MALLOC_INTERNAL
-#include <malloc.h>
-#endif
-
-__ptr_t (*__memalign_hook) PP ((__malloc_size_t __size,
-				__malloc_size_t __alignment));
-
-__ptr_t
-memalign (alignment, size)
-     __malloc_size_t alignment;
-     __malloc_size_t size;
+void *(*__memalign_hook) (size_t size, size_t alignment);
+
+void *
+memalign (size_t alignment, size_t size)
 {
-  __ptr_t result;
-  unsigned long int adj, lastadj;
-  __ptr_t (*hook) (__malloc_size_t, __malloc_size_t) = __memalign_hook;
+  void *result;
+  size_t adj, lastadj;
+  void *(*hook) (size_t, size_t) = __memalign_hook;

   if (hook)
     return (*hook) (alignment, size);
@@ -1703,7 +1590,7 @@

   /* Figure out how much we will need to pad this particular block
      to achieve the required alignment.  */
-  adj = (unsigned long int) ((char *) result - (char *) NULL) % alignment;
+  adj = (uintptr_t) result % alignment;

   do
     {
@@ -1714,7 +1601,7 @@
 	return NULL;

       lastadj = adj;
-      adj = (unsigned long int) ((char *) result - (char *) NULL) % alignment;
+      adj = (uintptr_t) result % alignment;
       /* It's conceivable we might have been so unlucky as to get a
 	 different block with weaker alignment.  If so, this block is too
 	 short to contain SIZE after alignment correction.  So we must
@@ -1735,7 +1622,7 @@
 	  break;
       if (l == NULL)
 	{
-	  l = (struct alignlist *) malloc (sizeof (struct alignlist));
+	  l = malloc (sizeof (struct alignlist));
 	  if (l != NULL)
 	    {
 	      l->next = _aligned_blocks;
@@ -1767,15 +1654,12 @@
 #endif

 int
-posix_memalign (memptr, alignment, size)
-     __ptr_t *memptr;
-     __malloc_size_t alignment;
-     __malloc_size_t size;
+posix_memalign (void **memptr, size_t alignment, size_t size)
 {
-  __ptr_t mem;
+  void *mem;

   if (alignment == 0
-      || alignment % sizeof (__ptr_t) != 0
+      || alignment % sizeof (void *) != 0
       || (alignment & (alignment - 1)) != 0)
     return EINVAL;

@@ -1809,43 +1693,27 @@
    The author may be reached (Email) at the address mike@ai.mit.edu,
    or (US mail) as Mike Haertel c/o Free Software Foundation.  */

-#if defined (_MALLOC_INTERNAL) && defined (GMALLOC_INHIBIT_VALLOC)
-
 /* Emacs defines GMALLOC_INHIBIT_VALLOC to avoid this definition
    on MSDOS, where it conflicts with a system header file.  */

-#define ELIDE_VALLOC
-
-#endif
-
-#ifndef	ELIDE_VALLOC
-
-#if defined (__GNU_LIBRARY__) || defined (_LIBC)
-#include <stddef.h>
-#include <sys/cdefs.h>
-#if defined (__GLIBC__) && __GLIBC__ >= 2
-/* __getpagesize is already declared in <unistd.h> with return type int */
-#else
-extern size_t __getpagesize PP ((void));
-#endif
-#else
-#include "getpagesize.h"
-#define	 __getpagesize()	getpagesize ()
-#endif
-
-#ifndef	_MALLOC_INTERNAL
-#define	_MALLOC_INTERNAL
-#include <malloc.h>
-#endif
-
-static __malloc_size_t pagesize;
-
-__ptr_t
-valloc (size)
-     __malloc_size_t size;
+#ifndef	GMALLOC_INHIBIT_VALLOC
+
+/* Allocate SIZE bytes on a page boundary.  */
+extern void *valloc (size_t);
+
+#if defined _SC_PAGESIZE || !defined HAVE_GETPAGESIZE
+# include "getpagesize.h"
+#elif !defined getpagesize
+extern int getpagesize (void);
+#endif
+
+static size_t pagesize;
+
+void *
+valloc (size_t size)
 {
   if (pagesize == 0)
-    pagesize = __getpagesize ();
+    pagesize = getpagesize ();

   return memalign (pagesize, size);
 }
@@ -1876,41 +1744,31 @@
    The author may be reached (Email) at the address mike@ai.mit.edu,
    or (US mail) as Mike Haertel c/o Free Software Foundation.  */

-#ifdef emacs
-#include <stdio.h>
-#else
-#ifndef	_MALLOC_INTERNAL
-#define	_MALLOC_INTERNAL
-#include <malloc.h>
-#include <stdio.h>
-#endif
-#endif
+#include <stdio.h>

 /* Old hook values.  */
-static void (*old_free_hook) (__ptr_t ptr);
-static __ptr_t (*old_malloc_hook) (__malloc_size_t size);
-static __ptr_t (*old_realloc_hook) (__ptr_t ptr, __malloc_size_t size);
+static void (*old_free_hook) (void *ptr);
+static void *(*old_malloc_hook) (size_t size);
+static void *(*old_realloc_hook) (void *ptr, size_t size);

 /* Function to call when something awful happens.  */
 static void (*abortfunc) (enum mcheck_status);

 /* Arbitrary magical numbers.  */
-#define MAGICWORD	0xfedabeeb
-#define MAGICFREE	0xd8675309
+#define MAGICWORD	(SIZE_MAX / 11 ^ SIZE_MAX / 13 << 3)
+#define MAGICFREE	(SIZE_MAX / 17 ^ SIZE_MAX / 19 << 4)
 #define MAGICBYTE	((char) 0xd7)
 #define MALLOCFLOOD	((char) 0x93)
 #define FREEFLOOD	((char) 0x95)

 struct hdr
   {
-    __malloc_size_t size;		/* Exact size requested by user.  */
-    unsigned long int magic;	/* Magic number to check header integrity.  */
+    size_t size;	/* Exact size requested by user.  */
+    size_t magic;	/* Magic number to check header integrity.  */
   };

-static enum mcheck_status checkhdr (const struct hdr *);
 static enum mcheck_status
-checkhdr (hdr)
-     const struct hdr *hdr;
+checkhdr (const struct hdr *hdr)
 {
   enum mcheck_status status;
   switch (hdr->magic)
@@ -1933,10 +1791,8 @@
   return status;
 }

-static void freehook (__ptr_t);
 static void
-freehook (ptr)
-     __ptr_t ptr;
+freehook (void *ptr)
 {
   struct hdr *hdr;

@@ -1955,15 +1811,13 @@
   __free_hook = freehook;
 }

-static __ptr_t mallochook (__malloc_size_t);
-static __ptr_t
-mallochook (size)
-     __malloc_size_t size;
+static void *
+mallochook (size_t size)
 {
   struct hdr *hdr;

   __malloc_hook = old_malloc_hook;
-  hdr = (struct hdr *) malloc (sizeof (struct hdr) + size + 1);
+  hdr = malloc (sizeof (struct hdr) + size + 1);
   __malloc_hook = mallochook;
   if (hdr == NULL)
     return NULL;
@@ -1971,18 +1825,15 @@
   hdr->size = size;
   hdr->magic = MAGICWORD;
   ((char *) &hdr[1])[size] = MAGICBYTE;
-  memset ((__ptr_t) (hdr + 1), MALLOCFLOOD, size);
-  return (__ptr_t) (hdr + 1);
+  memset (hdr + 1, MALLOCFLOOD, size);
+  return hdr + 1;
 }

-static __ptr_t reallochook (__ptr_t, __malloc_size_t);
-static __ptr_t
-reallochook (ptr, size)
-     __ptr_t ptr;
-     __malloc_size_t size;
+static void *
+reallochook (void *ptr, size_t size)
 {
   struct hdr *hdr = NULL;
-  __malloc_size_t osize = 0;
+  size_t osize = 0;

   if (ptr)
     {
@@ -1997,7 +1848,7 @@
   __free_hook = old_free_hook;
   __malloc_hook = old_malloc_hook;
   __realloc_hook = old_realloc_hook;
-  hdr = (struct hdr *) realloc ((__ptr_t) hdr, sizeof (struct hdr) + size + 1);
+  hdr = realloc (hdr, sizeof (struct hdr) + size + 1);
   __free_hook = freehook;
   __malloc_hook = mallochook;
   __realloc_hook = reallochook;
@@ -2009,12 +1860,11 @@
   ((char *) &hdr[1])[size] = MAGICBYTE;
   if (size > osize)
     memset ((char *) (hdr + 1) + osize, MALLOCFLOOD, size - osize);
-  return (__ptr_t) (hdr + 1);
+  return hdr + 1;
 }

 static void
-mabort (status)
-     enum mcheck_status status;
+mabort (enum mcheck_status status)
 {
   const char *msg;
   switch (status)
@@ -2047,8 +1897,7 @@
 static int mcheck_used = 0;

 int
-mcheck (func)
-     void (*func) (enum mcheck_status);
+mcheck (void (*func) (enum mcheck_status))
 {
   abortfunc = (func != NULL) ? func : &mabort;

@@ -2068,7 +1917,7 @@
 }

 enum mcheck_status
-mprobe (__ptr_t ptr)
+mprobe (void *ptr)
 {
   return mcheck_used ? checkhdr (ptr) : MCHECK_DISABLED;
 }

bug#9119: [PATCH] modernize function definitions in gmalloc.c

[Paul Eggert]

On 04/14/2012 04:15 AM, Ken Brown wrote:
> So I don't know if that patch should just be applied now
> or if Paul plans to do more cleanup.

I just now applied a slightly-updated version of the last
patch that I suggested in this thread, into the trunk as
bzr 107999, and I'm marking this as done.  The code is
still pretty crufty and I'm sure it still has bugs on some
platforms but someone who regularly debugs on those
platforms would need to look at it.