Simpilify PyCore_* macros by assuming the function prototypes for

malloc() and free() don't change.

Include/objimpl.h

@@ -77,40 +77,20 @@ recommended to use PyObject_{New, NewVar, Del}. */
    modules should use the PyObject_* API. */
 
 #ifdef WITH_PYMALLOC
-#define PyCore_OBJECT_MALLOC_FUNC    _PyCore_ObjectMalloc
-#define PyCore_OBJECT_REALLOC_FUNC   _PyCore_ObjectRealloc
-#define PyCore_OBJECT_FREE_FUNC      _PyCore_ObjectFree
-#define NEED_TO_DECLARE_OBJECT_MALLOC_AND_FRIEND
+void *_PyCore_ObjectMalloc(size_t nbytes);
+void *_PyCore_ObjectRealloc(void *p, size_t nbytes);
+void _PyCore_ObjectFree(void *p);
+#define PyCore_OBJECT_MALLOC    _PyCore_ObjectMalloc
+#define PyCore_OBJECT_REALLOC   _PyCore_ObjectRealloc
+#define PyCore_OBJECT_FREE      _PyCore_ObjectFree
 #endif /* !WITH_PYMALLOC */
 
-#ifndef PyCore_OBJECT_MALLOC_FUNC
-#undef PyCore_OBJECT_REALLOC_FUNC
-#undef PyCore_OBJECT_FREE_FUNC
-#define PyCore_OBJECT_MALLOC_FUNC    PyCore_MALLOC_FUNC
-#define PyCore_OBJECT_REALLOC_FUNC   PyCore_REALLOC_FUNC
-#define PyCore_OBJECT_FREE_FUNC      PyCore_FREE_FUNC
-#endif
-
-#ifndef PyCore_OBJECT_MALLOC_PROTO
-#undef PyCore_OBJECT_REALLOC_PROTO
-#undef PyCore_OBJECT_FREE_PROTO
-#define PyCore_OBJECT_MALLOC_PROTO   PyCore_MALLOC_PROTO
-#define PyCore_OBJECT_REALLOC_PROTO  PyCore_REALLOC_PROTO
-#define PyCore_OBJECT_FREE_PROTO     PyCore_FREE_PROTO
-#endif
-
-#ifdef NEED_TO_DECLARE_OBJECT_MALLOC_AND_FRIEND
-extern void *PyCore_OBJECT_MALLOC_FUNC PyCore_OBJECT_MALLOC_PROTO;
-extern void *PyCore_OBJECT_REALLOC_FUNC PyCore_OBJECT_REALLOC_PROTO;
-extern void PyCore_OBJECT_FREE_FUNC PyCore_OBJECT_FREE_PROTO;
-#endif
-
 #ifndef PyCore_OBJECT_MALLOC
 #undef PyCore_OBJECT_REALLOC
 #undef PyCore_OBJECT_FREE
-#define PyCore_OBJECT_MALLOC(n)      PyCore_OBJECT_MALLOC_FUNC(n)
-#define PyCore_OBJECT_REALLOC(p, n)  PyCore_OBJECT_REALLOC_FUNC((p), (n))
-#define PyCore_OBJECT_FREE(p)        PyCore_OBJECT_FREE_FUNC(p)
+#define PyCore_OBJECT_MALLOC(n)     PyCore_MALLOC(n)
+#define PyCore_OBJECT_REALLOC(p, n) PyCore_REALLOC((p), (n))
+#define PyCore_OBJECT_FREE(p)       PyCore_FREE(p)
 #endif
 
 /*

Include/pymem.h

@@ -20,39 +20,14 @@ extern "C" {
 
    The PyCore_* macros can be defined to make the interpreter use a
    custom allocator. Note that they are for internal use only. Both
-   the core and extension modules should use the PyMem_* API.
-
-   See the comment block at the end of this file for two scenarios
-   showing how to use this to use a different allocator. */
-
-#ifndef PyCore_MALLOC_FUNC
-#undef PyCore_REALLOC_FUNC
-#undef PyCore_FREE_FUNC
-#define PyCore_MALLOC_FUNC      malloc
-#define PyCore_REALLOC_FUNC     realloc
-#define PyCore_FREE_FUNC        free
-#endif
-
-#ifndef PyCore_MALLOC_PROTO
-#undef PyCore_REALLOC_PROTO
-#undef PyCore_FREE_PROTO
-#define PyCore_MALLOC_PROTO    (size_t)
-#define PyCore_REALLOC_PROTO   (void *, size_t)
-#define PyCore_FREE_PROTO      (void *)
-#endif
-
-#ifdef NEED_TO_DECLARE_MALLOC_AND_FRIEND
-extern void *PyCore_MALLOC_FUNC PyCore_MALLOC_PROTO;
-extern void *PyCore_REALLOC_FUNC PyCore_REALLOC_PROTO;
-extern void PyCore_FREE_FUNC PyCore_FREE_PROTO;
-#endif
+   the core and extension modules should use the PyMem_* API. */
 
 #ifndef PyCore_MALLOC
 #undef PyCore_REALLOC
 #undef PyCore_FREE
-#define PyCore_MALLOC(n)        PyCore_MALLOC_FUNC(n)
-#define PyCore_REALLOC(p, n)    PyCore_REALLOC_FUNC((p), (n))
-#define PyCore_FREE(p)          PyCore_FREE_FUNC(p)
+#define PyCore_MALLOC(n)      malloc(n)
+#define PyCore_REALLOC(p, n)  realloc((p), (n))
+#define PyCore_FREE(p)        free(p)
 #endif
 
 /* BEWARE:
@@ -133,43 +108,4 @@ extern DL_IMPORT(void) PyMem_Free(void *);
 }
 #endif
 
-/* SCENARIOS
-
-   Here are two scenarios by Vladimir Marangozov (the author of the
-   memory allocation redesign).
-
-   1) Scenario A
-
-   Suppose you want to use a debugging malloc library that collects info on
-   where the malloc calls originate from. Assume the interface is:
-
-   d_malloc(size_t n, char* src_file, unsigned long src_line) c.s.
-
-   In this case, you would define (for example in pyconfig.h) :
-
-   #define PyCore_MALLOC_FUNC      d_malloc
-   ...
-   #define PyCore_MALLOC_PROTO	(size_t, char *, unsigned long)
-   ...
-   #define NEED_TO_DECLARE_MALLOC_AND_FRIEND
-
-   #define PyCore_MALLOC(n)	PyCore_MALLOC_FUNC((n), __FILE__, __LINE__)
-   ...
-
-   2) Scenario B
-
-   Suppose you want to use malloc hooks (defined & initialized in a 3rd party
-   malloc library) instead of malloc functions.  In this case, you would
-   define:
-
-   #define PyCore_MALLOC_FUNC	(*malloc_hook)
-   ...
-   #define NEED_TO_DECLARE_MALLOC_AND_FRIEND
-
-   and ignore the previous definitions about PyCore_MALLOC_FUNC, etc.
-
-
-*/
-
-
 #endif /* !Py_PYMEM_H */

Objects/obmalloc.c

@@ -53,42 +53,6 @@
 
 /*==========================================================================*/
 
-/*
- * Public functions exported by this allocator.
- *
- * -- Define and use these names in your code to obtain or release memory --
- */
-#define _THIS_MALLOC		PyCore_OBJECT_MALLOC_FUNC
-#define _THIS_CALLOC		/* unused */
-#define _THIS_REALLOC		PyCore_OBJECT_REALLOC_FUNC
-#define _THIS_FREE		PyCore_OBJECT_FREE_FUNC
-
-/*
- * Underlying allocator's functions called by this allocator.
- * The underlying allocator is usually the one which comes with libc.
- *
- * -- Don't use these functions in your code (to avoid mixing allocators) --
- *
- * Redefine these __only__ if you are using a 3rd party general purpose
- * allocator which exports functions with names _other_ than the standard
- * malloc, calloc, realloc, free.
- */
-#define _SYSTEM_MALLOC		PyCore_MALLOC_FUNC
-#define _SYSTEM_CALLOC		/* unused */
-#define _SYSTEM_REALLOC		PyCore_REALLOC_FUNC
-#define _SYSTEM_FREE		PyCore_FREE_FUNC
-
-/*
- * If malloc hooks are needed, names of the hooks' set & fetch
- * functions exported by this allocator.
- */
-#ifdef WITH_MALLOC_HOOKS
-#define _SET_HOOKS		_PyCore_ObjectMalloc_SetHooks
-#define _FETCH_HOOKS		_PyCore_ObjectMalloc_FetchHooks
-#endif
-
-/*==========================================================================*/
-
 /*
  * Allocation strategy abstract:
  *
@@ -385,7 +349,7 @@ static void (*free_hook)(void *) = NULL;
  */
 
 void *
-_THIS_MALLOC(size_t nbytes)
+_PyCore_ObjectMalloc(size_t nbytes)
 {
 	block *bp;
 	poolp pool;
@@ -515,7 +479,7 @@ _THIS_MALLOC(size_t nbytes)
 		 * With malloc, we can't avoid loosing one page address space
 		 * per arena due to the required alignment on page boundaries.
 		 */
-		bp = (block *)_SYSTEM_MALLOC(ARENA_SIZE + SYSTEM_PAGE_SIZE);
+		bp = (block *)PyCore_MALLOC(ARENA_SIZE + SYSTEM_PAGE_SIZE);
 		if (bp == NULL) {
 			UNLOCK();
 			goto redirect;
@@ -546,13 +510,13 @@ _THIS_MALLOC(size_t nbytes)
 	 * last chance to serve the request) or when the max memory limit
 	 * has been reached.
 	 */
-	return (void *)_SYSTEM_MALLOC(nbytes);
+	return (void *)PyCore_MALLOC(nbytes);
 }
 
 /* free */
 
 void
-_THIS_FREE(void *p)
+_PyCore_ObjectFree(void *p)
 {
 	poolp pool;
 	poolp next, prev;
@@ -572,7 +536,7 @@ _THIS_FREE(void *p)
 	offset = (off_t )p & POOL_SIZE_MASK;
 	pool = (poolp )((block *)p - offset);
 	if (pool->pooladdr != pool || pool->magic != (uint )POOL_MAGIC) {
-		_SYSTEM_FREE(p);
+		PyCore_FREE(p);
 		return;
 	}
 
@@ -631,7 +595,7 @@ _THIS_FREE(void *p)
 /* realloc */
 
 void *
-_THIS_REALLOC(void *p, size_t nbytes)
+_PyCore_ObjectRealloc(void *p, size_t nbytes)
 {
 	block *bp;
 	poolp pool;
@@ -643,7 +607,7 @@ _THIS_REALLOC(void *p, size_t nbytes)
 #endif
 
 	if (p == NULL)
-		return _THIS_MALLOC(nbytes);
+		return _PyCore_ObjectMalloc(nbytes);
 
 	/* realloc(p, 0) on big blocks is redirected. */
 	pool = (poolp )((block *)p - ((off_t )p & POOL_SIZE_MASK));
@@ -654,7 +618,7 @@ _THIS_REALLOC(void *p, size_t nbytes)
 			size = nbytes;
 			goto malloc_copy_free;
 		}
-		bp = (block *)_SYSTEM_REALLOC(p, nbytes);
+		bp = (block *)PyCore_REALLOC(p, nbytes);
 	}
 	else {
 		/* We're in charge of this block */
@@ -663,7 +627,7 @@ _THIS_REALLOC(void *p, size_t nbytes)
 			/* Don't bother if a smaller size was requested
 			   except for realloc(p, 0) == free(p), ret NULL */
 			if (nbytes == 0) {
-				_THIS_FREE(p);
+				_PyCore_ObjectFree(p);
 				bp = NULL;
 			}
 			else
@@ -673,10 +637,10 @@ _THIS_REALLOC(void *p, size_t nbytes)
 
 		malloc_copy_free:
 
-			bp = (block *)_THIS_MALLOC(nbytes);
+			bp = (block *)_PyCore_ObjectMalloc(nbytes);
 			if (bp != NULL) {
 				memcpy(bp, p, size);
-				_THIS_FREE(p);
+				_PyCore_ObjectFree(p);
 			}
 		}
 	}
@@ -687,7 +651,7 @@ _THIS_REALLOC(void *p, size_t nbytes)
 
 /* -- unused --
 void *
-_THIS_CALLOC(size_t nbel, size_t elsz)
+_PyCore_ObjectCalloc(size_t nbel, size_t elsz)
 {
         void *p;
 	size_t nbytes;
@@ -698,7 +662,7 @@ _THIS_CALLOC(size_t nbel, size_t elsz)
 #endif
 
 	nbytes = nbel * elsz;
-	p = _THIS_MALLOC(nbytes);
+	p = _PyCore_ObjectMalloc(nbytes);
 	if (p != NULL)
 		memset(p, 0, nbytes);
 	return p;
@@ -714,10 +678,10 @@ _THIS_CALLOC(size_t nbel, size_t elsz)
 #ifdef WITH_MALLOC_HOOKS
 
 void
-_SET_HOOKS( void *(*malloc_func)(size_t),
-	    void *(*calloc_func)(size_t, size_t),
-	    void *(*realloc_func)(void *, size_t),
-	    void (*free_func)(void *) )
+_PyCore_ObjectMalloc_SetHooks( void *(*malloc_func)(size_t),
+			       void *(*calloc_func)(size_t, size_t),
+			       void *(*realloc_func)(void *, size_t),
+			       void (*free_func)(void *) )
 {
 	LOCK();
 	malloc_hook = malloc_func;
@@ -728,10 +692,10 @@ _SET_HOOKS( void *(*malloc_func)(size_t),
 }
 
 void
-_FETCH_HOOKS( void *(**malloc_funcp)(size_t),
-	      void *(**calloc_funcp)(size_t, size_t),
-              void *(**realloc_funcp)(void *, size_t),
-              void (**free_funcp)(void *) )
+_PyCore_ObjectMalloc_FetchHooks( void *(**malloc_funcp)(size_t),
+				 void *(**calloc_funcp)(size_t, size_t),
+				 void *(**realloc_funcp)(void *, size_t),
+				 void (**free_funcp)(void *) )
 {
 	LOCK();
 	*malloc_funcp = malloc_hook;