[rfc/rfa?] Rationalize *malloc() calling *malloc()

Andrew Cagney ac131313@cygnus.com
Mon Mar 19 18:43:00 GMT 2001


Hello,

The attached patch rationalizes the way the different malloc() variants
call each other.  After this patch the sequence is hopefully:

	for malloc in malloc realloc calloc free
		x$malloc()
		-> xm$malloc()
		-> m$malloc()

For the sake of consistency, it also introduces:

	xmcalloc()
	xmfree()

I'll leave it as an exercise to the reader to figure out what the
current codes ordering convention is :-)

comments?

	Andrew
2001-03-19  Andrew Cagney  <ac131313@redhat.com>

	* defs.h (xfree, mcalloc, mmalloc, mrealloc, mfree, xmmalloc,
	xmrealloc): Move existing declarations to the one place and
	re-order to be consistent.
	(xmcalloc, xmfree): Declare.
	(xmmalloc, xmrealoc): Assume ISO-C - use size_t size_t and void*
	in declaration.
	
	* utils.c (size_t): Delete #ifdef defining size_t.
	(mmalloc, mrealloc, mcalloc, mfree): Re-order.
	(mmalloc, mrealloc, mcalloc): Document as only calls in GDB
	corresponding malloc, realloc, calloc.
	(mfree): Call free directly.
	(xmmalloc, xmrealloc): Clean up. Assume ISO-C.
	(xmcalloc, xmfree): New functions. Copy old xcalloc and xfree
	function bodies to here.
	(xcalloc, xfree): Call xmcalloc and xmfree respectfully.
	
Index: defs.h
===================================================================
RCS file: /cvs/src/src/gdb/defs.h,v
retrieving revision 1.46
diff -p -r1.46 defs.h
*** defs.h	2001/03/20 01:37:09	1.46
--- defs.h	2001/03/20 02:37:11
*************** extern void free_current_contents (void 
*** 367,388 ****
  
  extern void null_cleanup (void *);
  
- extern void xfree (void *);
- 
  extern int myread (int, char *, int);
  
  extern int query (char *, ...) ATTR_FORMAT (printf, 1, 2);
  
- #if !defined (USE_MMALLOC)
- /* NOTE: cagney/2000-03-04: The mmalloc functions need to use PTR
-    rather than void* so that they are consistent with
-    ../mmalloc/mmalloc.h. */
- extern PTR mcalloc (PTR, size_t, size_t);
- extern PTR mmalloc (PTR, size_t);
- extern PTR mrealloc (PTR, PTR, size_t);
- extern void mfree (PTR, PTR);
- #endif
- 
  extern void init_page_info (void);
  
  extern CORE_ADDR host_pointer_to_address (void *ptr);
--- 367,376 ----
*************** extern char *msavestring (void *, const 
*** 810,824 ****
  
  extern char *mstrsave (void *, const char *);
  
! /* FIXME; was long, but this causes compile errors in msvc if already
!    defined */
! #ifdef _MSC_VER
! extern PTR xmmalloc (PTR, size_t);
! extern PTR xmrealloc (PTR, PTR, size_t);
! #else
! extern PTR xmmalloc (PTR, long);
! extern PTR xmrealloc (PTR, PTR, long);
  #endif
  
  /* Like asprintf/vasprintf but get an internal_error if the call
     fails. */
--- 798,823 ----
  
  extern char *mstrsave (void *, const char *);
  
! #if !defined (USE_MMALLOC)
! /* NOTE: cagney/2000-03-04: The mmalloc functions need to use PTR
!    rather than void* so that they are consistent with the delcaration
!    in ../mmalloc/mmalloc.h. */
! extern PTR mcalloc (PTR, size_t, size_t);
! extern PTR mmalloc (PTR, size_t);
! extern PTR mrealloc (PTR, PTR, size_t);
! extern void mfree (PTR, PTR);
  #endif
+ 
+ /* Robust versions of same.  Throw an internal error when no memory,
+    guard against stray NULL arguments. */
+ extern void *xmmalloc (void *md, size_t size);
+ extern void *xmrealloc (void *md, void *ptr, size_t size);
+ extern void *xmcalloc (void *md, size_t number, size_t size);
+ extern void xmfree (void *md, void *ptr);
+ 
+ /* xmalloc(), xrealloc() and xcalloc() have already been declared in
+    "libiberty.h". */
+ extern void xfree (void *);
  
  /* Like asprintf/vasprintf but get an internal_error if the call
     fails. */
Index: utils.c
===================================================================
RCS file: /cvs/src/src/gdb/utils.c,v
retrieving revision 1.38
diff -p -r1.38 utils.c
*** utils.c	2001/03/20 01:37:09	1.38
--- utils.c	2001/03/20 02:37:24
*************** request_quit (int signo)
*** 917,957 ****
  
  /* Memory management stuff (malloc friends).  */
  
- /* Make a substitute size_t for non-ANSI compilers. */
- 
- #ifndef HAVE_STDDEF_H
- #ifndef size_t
- #define size_t unsigned int
- #endif
- #endif
- 
  #if !defined (USE_MMALLOC)
  
! PTR
! mcalloc (PTR md, size_t number, size_t size)
! {
!   return calloc (number, size);
! }
  
  PTR
  mmalloc (PTR md, size_t size)
  {
!   return malloc (size);
  }
  
  PTR
  mrealloc (PTR md, PTR ptr, size_t size)
  {
    if (ptr == 0)			/* Guard against old realloc's */
!     return malloc (size);
    else
!     return realloc (ptr, size);
  }
  
  void
  mfree (PTR md, PTR ptr)
  {
!   xfree (ptr);
  }
  
  #endif /* USE_MMALLOC */
--- 917,952 ----
  
  /* Memory management stuff (malloc friends).  */
  
  #if !defined (USE_MMALLOC)
  
! /* NOTE: These must use PTR so that their definition matches the
!    declaration found in mmalloc.h. */
  
  PTR
  mmalloc (PTR md, size_t size)
  {
!   return malloc (size); /* NOTE: GDB's only call to malloc() */
  }
  
  PTR
  mrealloc (PTR md, PTR ptr, size_t size)
  {
    if (ptr == 0)			/* Guard against old realloc's */
!     return mmalloc (md, size);
    else
!     return realloc (ptr, size); /* NOTE: GDB's only call to ralloc() */
! }
! 
! PTR
! mcalloc (PTR md, size_t number, size_t size)
! {
!   return calloc (number, size); /* NOTE: GDB's only call to calloc() */
  }
  
  void
  mfree (PTR md, PTR ptr)
  {
!   free (ptr); /* NOTE: GDB's only call to free() */
  }
  
  #endif /* USE_MMALLOC */
*************** nomem (long size)
*** 1028,1060 ****
      }
  }
  
! /* Like mmalloc but get error if no storage available, and protect against
!    the caller wanting to allocate zero bytes.  Whether to return NULL for
!    a zero byte request, or translate the request into a request for one
!    byte of zero'd storage, is a religious issue. */
  
! PTR
! xmmalloc (PTR md, long size)
  {
!   register PTR val;
  
    if (size == 0)
      {
        val = NULL;
      }
!   else if ((val = mmalloc (md, size)) == NULL)
      {
!       nomem (size);
      }
    return (val);
  }
- 
- /* Like mrealloc but get error if no storage available.  */
  
! PTR
! xmrealloc (PTR md, PTR ptr, long size)
  {
!   register PTR val;
  
    if (size == 0)
      {
--- 1023,1055 ----
      }
  }
  
! /* Like malloc(), realloc(), calloc() and free() but guard against
!    NULL pointers.  If an allocate fails, throw an internal error,
!    during a free, just ignore it.  Returns NULL when the allocated
!    size is zero (an arbitrary choice).  */
  
! void *
! xmmalloc (void *md, size_t size)
  {
!   void *val;
  
    if (size == 0)
      {
        val = NULL;
      }
!   else
      {
!       val = mmalloc (md, size);
!       if (val == NULL)
! 	nomem (size);
      }
    return (val);
  }
  
! void *
! xmrealloc (void *md, void *ptr, size_t size)
  {
!   void *val;
  
    if (size == 0)
      {
*************** xmrealloc (PTR md, PTR ptr, long size)
*** 1079,1128 ****
      }
    return (val);
  }
- 
- /* Like malloc but get error if no storage available, and protect against
-    the caller wanting to allocate zero bytes.  */
  
! PTR
! xmalloc (size_t size)
  {
-   return (xmmalloc ((PTR) NULL, size));
- }
- 
- /* Like calloc but get error if no storage available */
- 
- PTR
- xcalloc (size_t number, size_t size)
- {
    void *mem;
- 
    if (number == 0 || size == 0)
      mem = NULL;
    else
      {
!       mem = mcalloc (NULL, number, size);
        if (mem == NULL)
  	nomem (number * size);
      }
    return mem;
  }
  
! /* Like mrealloc but get error if no storage available.  */
  
  PTR
  xrealloc (PTR ptr, size_t size)
  {
!   return (xmrealloc ((PTR) NULL, ptr, size));
  }
  
! /* Free up space allocated by one of xmalloc(), xcalloc(), or
!    xrealloc().  */
  
  void
  xfree (void *ptr)
  {
!   if (ptr != NULL)
!     free (ptr); /* NOTE: GDB's only call to free() */
  }
  
  
--- 1074,1128 ----
      }
    return (val);
  }
  
! void *
! xmcalloc (void *md, size_t number, size_t size)
  {
    void *mem;
    if (number == 0 || size == 0)
      mem = NULL;
    else
      {
!       mem = mcalloc (md, number, size);
        if (mem == NULL)
  	nomem (number * size);
      }
    return mem;
  }
+ 
+ void
+ xmfree (void *md, void *ptr)
+ {
+   if (ptr != NULL)
+     mfree (md, ptr);
+ }
  
! /* Non- MMALLOC equivalents to xmalloc() et.al. */
! /* NOTE: These are declared using PTR to ensure consistency with
!    "libiberty.h". */
  
  PTR
+ xmalloc (size_t size)
+ {
+   return xmmalloc (NULL, size);
+ }
+ 
+ PTR
  xrealloc (PTR ptr, size_t size)
  {
!   return xmrealloc (NULL, ptr, size);
  }
  
! PTR
! xcalloc (size_t number, size_t size)
! {
!   return xmcalloc (NULL, number, size);
! }
  
  void
  xfree (void *ptr)
  {
!   xmfree (NULL, ptr);
  }
  
  


More information about the Gdb-patches mailing list