mirror of
https://github.com/php/php-src.git
synced 2025-08-15 21:48:51 +02:00
Drop zend_mm_set_custom_debug_handlers() (#13457)
Simplifies zend_mm_set_custom_debug_handlers to just use zend_mm_set_custom_handlers(), saving some conditionals when the Zend allocator is not used.
This commit is contained in:
Florian Engelhardt
GitHub
parent
ba27fab862
commit
14873dd286
8 changed files with 114 additions and 137 deletions
|
|
@ -40,6 +40,44 @@ PHP 8.4 INTERNALS UPGRADE NOTES
|
|||
* The inet_aton() and win32/inet.h on Windows have been removed. Use Windows
|
||||
native inet_pton() from ws2tcpip.h.
|
||||
|
||||
* zend_mm_set_custom_debug_handlers() has been removed from ZendMM, use
|
||||
zend_mm_set_custom_handlers() instead which now supports DEBUG builds
|
||||
|
||||
* zend_mm_set_custom_handlers() has changed its signature from
|
||||
void()(zend_mm_heap *heap,
|
||||
void* (*_malloc)(size_t),
|
||||
void (*_free)(void*),
|
||||
void* (*_realloc)(void*, size_t))
|
||||
to
|
||||
void()(zend_mm_heap *heap,
|
||||
void* (*_malloc)(size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC),
|
||||
void (*_free)(void* ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC),
|
||||
void* (*_realloc)(void*, size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC))
|
||||
|
||||
* zend_mm_get_custom_handlers() has changed its signature from
|
||||
void()(zend_mm_heap *heap,
|
||||
void* (**_malloc)(size_t),
|
||||
void (**_free)(void*),
|
||||
void* (**_realloc)(void*, size_t))
|
||||
to
|
||||
void()(zend_mm_heap *heap,
|
||||
void* (**_malloc)(size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC),
|
||||
void (**_free)(void* ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC),
|
||||
void* (**_realloc)(void*, size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC))
|
||||
|
||||
* __zend_malloc() has changed their signature from
|
||||
void(*)(size_t) to
|
||||
void(*)(size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
|
||||
|
||||
* __zend_calloc() has changed their signature from
|
||||
void(*)(size_t, size_t) to
|
||||
void(*)(size_t, size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
|
||||
|
||||
* __zend_realloc() has changed their signature from
|
||||
void(*)(void *, size_t) to
|
||||
void(*)(void *, size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
|
||||
|
||||
|
||||
========================
|
||||
2. Build system changes
|
||||
========================
|
||||
|
|
|
|||
|
|
@ -268,17 +268,10 @@ struct _zend_mm_heap {
|
|||
int last_chunks_delete_boundary; /* number of chunks after last deletion */
|
||||
int last_chunks_delete_count; /* number of deletion over the last boundary */
|
||||
#if ZEND_MM_CUSTOM
|
||||
union {
|
||||
struct {
|
||||
void *(*_malloc)(size_t);
|
||||
void (*_free)(void*);
|
||||
void *(*_realloc)(void*, size_t);
|
||||
} std;
|
||||
struct {
|
||||
void *(*_malloc)(size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
|
||||
void (*_free)(void* ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
|
||||
void *(*_realloc)(void*, size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
|
||||
} debug;
|
||||
struct {
|
||||
void *(*_malloc)(size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
|
||||
void (*_free)(void* ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
|
||||
void *(*_realloc)(void*, size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
|
||||
} custom_heap;
|
||||
HashTable *tracked_allocs;
|
||||
#endif
|
||||
|
|
@ -2261,7 +2254,7 @@ static void zend_mm_check_leaks(zend_mm_heap *heap)
|
|||
#endif
|
||||
|
||||
#if ZEND_MM_CUSTOM
|
||||
static void *tracked_malloc(size_t size);
|
||||
static void *tracked_malloc(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
|
||||
static void tracked_free_all(void);
|
||||
#endif
|
||||
|
||||
|
|
@ -2272,7 +2265,7 @@ void zend_mm_shutdown(zend_mm_heap *heap, bool full, bool silent)
|
|||
|
||||
#if ZEND_MM_CUSTOM
|
||||
if (heap->use_custom_heap) {
|
||||
if (heap->custom_heap.std._malloc == tracked_malloc) {
|
||||
if (heap->custom_heap._malloc == tracked_malloc) {
|
||||
if (silent) {
|
||||
tracked_free_all();
|
||||
}
|
||||
|
|
@ -2281,17 +2274,13 @@ void zend_mm_shutdown(zend_mm_heap *heap, bool full, bool silent)
|
|||
zend_hash_destroy(heap->tracked_allocs);
|
||||
free(heap->tracked_allocs);
|
||||
/* Make sure the heap free below does not use tracked_free(). */
|
||||
heap->custom_heap.std._free = free;
|
||||
heap->custom_heap._free = __zend_free;
|
||||
}
|
||||
heap->size = 0;
|
||||
}
|
||||
|
||||
if (full) {
|
||||
if (ZEND_DEBUG && heap->use_custom_heap == ZEND_MM_CUSTOM_HEAP_DEBUG) {
|
||||
heap->custom_heap.debug._free(heap ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC);
|
||||
} else {
|
||||
heap->custom_heap.std._free(heap);
|
||||
}
|
||||
heap->custom_heap._free(heap ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
|
@ -2412,7 +2401,7 @@ ZEND_API size_t ZEND_FASTCALL _zend_mm_block_size(zend_mm_heap *heap, void *ptr
|
|||
{
|
||||
#if ZEND_MM_CUSTOM
|
||||
if (UNEXPECTED(heap->use_custom_heap)) {
|
||||
if (heap->custom_heap.std._malloc == tracked_malloc) {
|
||||
if (heap->custom_heap._malloc == tracked_malloc) {
|
||||
zend_ulong h = ((uintptr_t) ptr) >> ZEND_MM_ALIGNMENT_LOG2;
|
||||
zval *size_zv = zend_hash_index_find(heap->tracked_allocs, h);
|
||||
if (size_zv) {
|
||||
|
|
@ -2455,7 +2444,7 @@ ZEND_API bool is_zend_ptr(const void *ptr)
|
|||
{
|
||||
#if ZEND_MM_CUSTOM
|
||||
if (AG(mm_heap)->use_custom_heap) {
|
||||
if (AG(mm_heap)->custom_heap.std._malloc == tracked_malloc) {
|
||||
if (AG(mm_heap)->custom_heap._malloc == tracked_malloc) {
|
||||
zend_ulong h = ((uintptr_t) ptr) >> ZEND_MM_ALIGNMENT_LOG2;
|
||||
zval *size_zv = zend_hash_index_find(AG(mm_heap)->tracked_allocs, h);
|
||||
if (size_zv) {
|
||||
|
|
@ -2492,48 +2481,18 @@ ZEND_API bool is_zend_ptr(const void *ptr)
|
|||
return 0;
|
||||
}
|
||||
|
||||
#if ZEND_MM_CUSTOM
|
||||
|
||||
static ZEND_COLD void* ZEND_FASTCALL _malloc_custom(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
|
||||
{
|
||||
if (ZEND_DEBUG && AG(mm_heap)->use_custom_heap == ZEND_MM_CUSTOM_HEAP_DEBUG) {
|
||||
return AG(mm_heap)->custom_heap.debug._malloc(size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
|
||||
} else {
|
||||
return AG(mm_heap)->custom_heap.std._malloc(size);
|
||||
}
|
||||
}
|
||||
|
||||
static ZEND_COLD void ZEND_FASTCALL _efree_custom(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
|
||||
{
|
||||
if (ZEND_DEBUG && AG(mm_heap)->use_custom_heap == ZEND_MM_CUSTOM_HEAP_DEBUG) {
|
||||
AG(mm_heap)->custom_heap.debug._free(ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
|
||||
} else {
|
||||
AG(mm_heap)->custom_heap.std._free(ptr);
|
||||
}
|
||||
}
|
||||
|
||||
static ZEND_COLD void* ZEND_FASTCALL _realloc_custom(void *ptr, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
|
||||
{
|
||||
if (ZEND_DEBUG && AG(mm_heap)->use_custom_heap == ZEND_MM_CUSTOM_HEAP_DEBUG) {
|
||||
return AG(mm_heap)->custom_heap.debug._realloc(ptr, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
|
||||
} else {
|
||||
return AG(mm_heap)->custom_heap.std._realloc(ptr, size);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#if !ZEND_DEBUG && defined(HAVE_BUILTIN_CONSTANT_P)
|
||||
#undef _emalloc
|
||||
|
||||
#if ZEND_MM_CUSTOM
|
||||
# define ZEND_MM_CUSTOM_ALLOCATOR(size) do { \
|
||||
if (UNEXPECTED(AG(mm_heap)->use_custom_heap)) { \
|
||||
return _malloc_custom(size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); \
|
||||
return AG(mm_heap)->custom_heap._malloc(size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); \
|
||||
} \
|
||||
} while (0)
|
||||
# define ZEND_MM_CUSTOM_DEALLOCATOR(ptr) do { \
|
||||
if (UNEXPECTED(AG(mm_heap)->use_custom_heap)) { \
|
||||
_efree_custom(ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); \
|
||||
AG(mm_heap)->custom_heap._free(ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); \
|
||||
return; \
|
||||
} \
|
||||
} while (0)
|
||||
|
|
@ -2618,7 +2577,7 @@ ZEND_API void* ZEND_FASTCALL _emalloc(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LI
|
|||
{
|
||||
#if ZEND_MM_CUSTOM
|
||||
if (UNEXPECTED(AG(mm_heap)->use_custom_heap)) {
|
||||
return _malloc_custom(size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
|
||||
return AG(mm_heap)->custom_heap._malloc(size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC); \
|
||||
}
|
||||
#endif
|
||||
return zend_mm_alloc_heap(AG(mm_heap), size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
|
||||
|
|
@ -2628,7 +2587,7 @@ ZEND_API void ZEND_FASTCALL _efree(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_OR
|
|||
{
|
||||
#if ZEND_MM_CUSTOM
|
||||
if (UNEXPECTED(AG(mm_heap)->use_custom_heap)) {
|
||||
_efree_custom(ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
|
||||
AG(mm_heap)->custom_heap._free(ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
|
@ -2639,7 +2598,7 @@ ZEND_API void* ZEND_FASTCALL _erealloc(void *ptr, size_t size ZEND_FILE_LINE_DC
|
|||
{
|
||||
#if ZEND_MM_CUSTOM
|
||||
if (UNEXPECTED(AG(mm_heap)->use_custom_heap)) {
|
||||
return _realloc_custom(ptr, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
|
||||
return AG(mm_heap)->custom_heap._realloc(ptr, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
|
||||
}
|
||||
#endif
|
||||
return zend_mm_realloc_heap(AG(mm_heap), ptr, size, 0, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
|
||||
|
|
@ -2649,7 +2608,7 @@ ZEND_API void* ZEND_FASTCALL _erealloc2(void *ptr, size_t size, size_t copy_size
|
|||
{
|
||||
#if ZEND_MM_CUSTOM
|
||||
if (UNEXPECTED(AG(mm_heap)->use_custom_heap)) {
|
||||
return _realloc_custom(ptr, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
|
||||
return AG(mm_heap)->custom_heap._realloc(ptr, size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
|
||||
}
|
||||
#endif
|
||||
return zend_mm_realloc_heap(AG(mm_heap), ptr, size, 1, copy_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
|
||||
|
|
@ -2844,7 +2803,7 @@ static zend_always_inline void tracked_check_limit(zend_mm_heap *heap, size_t ad
|
|||
}
|
||||
}
|
||||
|
||||
static void *tracked_malloc(size_t size)
|
||||
static void *tracked_malloc(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
|
||||
{
|
||||
zend_mm_heap *heap = AG(mm_heap);
|
||||
tracked_check_limit(heap, size);
|
||||
|
|
@ -2859,7 +2818,7 @@ static void *tracked_malloc(size_t size)
|
|||
return ptr;
|
||||
}
|
||||
|
||||
static void tracked_free(void *ptr) {
|
||||
static void tracked_free(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) {
|
||||
if (!ptr) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -2871,7 +2830,7 @@ static void tracked_free(void *ptr) {
|
|||
free(ptr);
|
||||
}
|
||||
|
||||
static void *tracked_realloc(void *ptr, size_t new_size) {
|
||||
static void *tracked_realloc(void *ptr, size_t new_size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) {
|
||||
zend_mm_heap *heap = AG(mm_heap);
|
||||
zval *old_size_zv = NULL;
|
||||
size_t old_size = 0;
|
||||
|
|
@ -2889,7 +2848,7 @@ static void *tracked_realloc(void *ptr, size_t new_size) {
|
|||
zend_hash_del_bucket(heap->tracked_allocs, (Bucket *) old_size_zv);
|
||||
}
|
||||
|
||||
ptr = __zend_realloc(ptr, new_size);
|
||||
ptr = __zend_realloc(ptr, new_size ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
|
||||
tracked_add(heap, ptr, new_size);
|
||||
heap->size += new_size - old_size;
|
||||
return ptr;
|
||||
|
|
@ -2921,14 +2880,14 @@ static void alloc_globals_ctor(zend_alloc_globals *alloc_globals)
|
|||
|
||||
if (!tracked) {
|
||||
/* Use system allocator. */
|
||||
mm_heap->custom_heap.std._malloc = __zend_malloc;
|
||||
mm_heap->custom_heap.std._free = free;
|
||||
mm_heap->custom_heap.std._realloc = __zend_realloc;
|
||||
mm_heap->custom_heap._malloc = __zend_malloc;
|
||||
mm_heap->custom_heap._free = __zend_free;
|
||||
mm_heap->custom_heap._realloc = __zend_realloc;
|
||||
} else {
|
||||
/* Use system allocator and track allocations for auto-free. */
|
||||
mm_heap->custom_heap.std._malloc = tracked_malloc;
|
||||
mm_heap->custom_heap.std._free = tracked_free;
|
||||
mm_heap->custom_heap.std._realloc = tracked_realloc;
|
||||
mm_heap->custom_heap._malloc = tracked_malloc;
|
||||
mm_heap->custom_heap._free = tracked_free;
|
||||
mm_heap->custom_heap._realloc = tracked_realloc;
|
||||
mm_heap->tracked_allocs = malloc(sizeof(HashTable));
|
||||
zend_hash_init(mm_heap->tracked_allocs, 1024, NULL, NULL, 1);
|
||||
}
|
||||
|
|
@ -2990,9 +2949,9 @@ ZEND_API bool zend_mm_is_custom_heap(zend_mm_heap *new_heap)
|
|||
}
|
||||
|
||||
ZEND_API void zend_mm_set_custom_handlers(zend_mm_heap *heap,
|
||||
void* (*_malloc)(size_t),
|
||||
void (*_free)(void*),
|
||||
void* (*_realloc)(void*, size_t))
|
||||
void* (*_malloc)(size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC),
|
||||
void (*_free)(void* ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC),
|
||||
void* (*_realloc)(void*, size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC))
|
||||
{
|
||||
#if ZEND_MM_CUSTOM
|
||||
zend_mm_heap *_heap = (zend_mm_heap*)heap;
|
||||
|
|
@ -3001,25 +2960,25 @@ ZEND_API void zend_mm_set_custom_handlers(zend_mm_heap *heap,
|
|||
_heap->use_custom_heap = ZEND_MM_CUSTOM_HEAP_NONE;
|
||||
} else {
|
||||
_heap->use_custom_heap = ZEND_MM_CUSTOM_HEAP_STD;
|
||||
_heap->custom_heap.std._malloc = _malloc;
|
||||
_heap->custom_heap.std._free = _free;
|
||||
_heap->custom_heap.std._realloc = _realloc;
|
||||
_heap->custom_heap._malloc = _malloc;
|
||||
_heap->custom_heap._free = _free;
|
||||
_heap->custom_heap._realloc = _realloc;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
ZEND_API void zend_mm_get_custom_handlers(zend_mm_heap *heap,
|
||||
void* (**_malloc)(size_t),
|
||||
void (**_free)(void*),
|
||||
void* (**_realloc)(void*, size_t))
|
||||
void* (**_malloc)(size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC),
|
||||
void (**_free)(void* ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC),
|
||||
void* (**_realloc)(void*, size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC))
|
||||
{
|
||||
#if ZEND_MM_CUSTOM
|
||||
zend_mm_heap *_heap = (zend_mm_heap*)heap;
|
||||
|
||||
if (heap->use_custom_heap) {
|
||||
*_malloc = _heap->custom_heap.std._malloc;
|
||||
*_free = _heap->custom_heap.std._free;
|
||||
*_realloc = _heap->custom_heap.std._realloc;
|
||||
*_malloc = _heap->custom_heap._malloc;
|
||||
*_free = _heap->custom_heap._free;
|
||||
*_realloc = _heap->custom_heap._realloc;
|
||||
} else {
|
||||
*_malloc = NULL;
|
||||
*_free = NULL;
|
||||
|
|
@ -3032,23 +2991,6 @@ ZEND_API void zend_mm_get_custom_handlers(zend_mm_heap *heap,
|
|||
#endif
|
||||
}
|
||||
|
||||
#if ZEND_DEBUG
|
||||
ZEND_API void zend_mm_set_custom_debug_handlers(zend_mm_heap *heap,
|
||||
void* (*_malloc)(size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC),
|
||||
void (*_free)(void* ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC),
|
||||
void* (*_realloc)(void*, size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC))
|
||||
{
|
||||
#if ZEND_MM_CUSTOM
|
||||
zend_mm_heap *_heap = (zend_mm_heap*)heap;
|
||||
|
||||
_heap->use_custom_heap = ZEND_MM_CUSTOM_HEAP_DEBUG;
|
||||
_heap->custom_heap.debug._malloc = _malloc;
|
||||
_heap->custom_heap.debug._free = _free;
|
||||
_heap->custom_heap.debug._realloc = _realloc;
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
ZEND_API zend_mm_storage *zend_mm_get_storage(zend_mm_heap *heap)
|
||||
{
|
||||
#if ZEND_MM_STORAGE
|
||||
|
|
@ -3134,7 +3076,7 @@ ZEND_API zend_mm_heap *zend_mm_startup_ex(const zend_mm_handlers *handlers, void
|
|||
#endif
|
||||
}
|
||||
|
||||
ZEND_API void * __zend_malloc(size_t len)
|
||||
ZEND_API void * __zend_malloc(size_t len ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
|
||||
{
|
||||
void *tmp = malloc(len);
|
||||
if (EXPECTED(tmp || !len)) {
|
||||
|
|
@ -3143,17 +3085,17 @@ ZEND_API void * __zend_malloc(size_t len)
|
|||
zend_out_of_memory();
|
||||
}
|
||||
|
||||
ZEND_API void * __zend_calloc(size_t nmemb, size_t len)
|
||||
ZEND_API void * __zend_calloc(size_t nmemb, size_t len ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
|
||||
{
|
||||
void *tmp;
|
||||
|
||||
len = zend_safe_address_guarded(nmemb, len, 0);
|
||||
tmp = __zend_malloc(len);
|
||||
tmp = __zend_malloc(len ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
|
||||
memset(tmp, 0, len);
|
||||
return tmp;
|
||||
}
|
||||
|
||||
ZEND_API void * __zend_realloc(void *p, size_t len)
|
||||
ZEND_API void * __zend_realloc(void *p, size_t len ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
|
||||
{
|
||||
p = realloc(p, len);
|
||||
if (EXPECTED(p || !len)) {
|
||||
|
|
@ -3162,6 +3104,12 @@ ZEND_API void * __zend_realloc(void *p, size_t len)
|
|||
zend_out_of_memory();
|
||||
}
|
||||
|
||||
ZEND_API void __zend_free(void *p ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
|
||||
{
|
||||
free(p);
|
||||
return;
|
||||
}
|
||||
|
||||
ZEND_API char * __zend_strdup(const char *s)
|
||||
{
|
||||
char *tmp = strdup(s);
|
||||
|
|
|
|||
|
|
@ -178,13 +178,14 @@ ZEND_API void ZEND_FASTCALL _efree_huge(void *, size_t size);
|
|||
#define estrndup_rel(s, length) _estrndup((s), (length) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
|
||||
#define zend_mem_block_size_rel(ptr) _zend_mem_block_size((ptr) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
|
||||
|
||||
ZEND_API ZEND_ATTRIBUTE_MALLOC void * __zend_malloc(size_t len) ZEND_ATTRIBUTE_ALLOC_SIZE(1);
|
||||
ZEND_API ZEND_ATTRIBUTE_MALLOC void * __zend_calloc(size_t nmemb, size_t len) ZEND_ATTRIBUTE_ALLOC_SIZE2(1,2);
|
||||
ZEND_API void * __zend_realloc(void *p, size_t len) ZEND_ATTRIBUTE_ALLOC_SIZE(2);
|
||||
ZEND_API ZEND_ATTRIBUTE_MALLOC void * __zend_malloc(size_t len ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_ALLOC_SIZE(1);
|
||||
ZEND_API ZEND_ATTRIBUTE_MALLOC void * __zend_calloc(size_t nmemb, size_t len ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_ALLOC_SIZE2(1,2);
|
||||
ZEND_API void * __zend_realloc(void *p, size_t len ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_ALLOC_SIZE(2);
|
||||
ZEND_API void __zend_free(void *p ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
|
||||
ZEND_API ZEND_ATTRIBUTE_MALLOC char * __zend_strdup(const char *s);
|
||||
|
||||
/* Selective persistent/non persistent allocation macros */
|
||||
#define pemalloc(size, persistent) ((persistent)?__zend_malloc(size):emalloc(size))
|
||||
#define pemalloc(size, persistent) ((persistent)?__zend_malloc(size ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC):emalloc(size))
|
||||
#define safe_pemalloc(nmemb, size, offset, persistent) ((persistent)?_safe_malloc(nmemb, size, offset):safe_emalloc(nmemb, size, offset))
|
||||
#define pefree(ptr, persistent) ((persistent)?free(ptr):efree(ptr))
|
||||
#define pefree_size(ptr, size, persistent) do { \
|
||||
|
|
@ -195,20 +196,20 @@ ZEND_API ZEND_ATTRIBUTE_MALLOC char * __zend_strdup(const char *s);
|
|||
} \
|
||||
} while (0)
|
||||
|
||||
#define pecalloc(nmemb, size, persistent) ((persistent)?__zend_calloc((nmemb), (size)):ecalloc((nmemb), (size)))
|
||||
#define perealloc(ptr, size, persistent) ((persistent)?__zend_realloc((ptr), (size)):erealloc((ptr), (size)))
|
||||
#define perealloc2(ptr, size, copy_size, persistent) ((persistent)?__zend_realloc((ptr), (size)):erealloc2((ptr), (size), (copy_size)))
|
||||
#define pecalloc(nmemb, size, persistent) ((persistent)?__zend_calloc((nmemb), (size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC):ecalloc((nmemb), (size)))
|
||||
#define perealloc(ptr, size, persistent) ((persistent)?__zend_realloc((ptr), (size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC):erealloc((ptr), (size)))
|
||||
#define perealloc2(ptr, size, copy_size, persistent) ((persistent)?__zend_realloc((ptr), (size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC):erealloc2((ptr), (size), (copy_size)))
|
||||
#define safe_perealloc(ptr, nmemb, size, offset, persistent) ((persistent)?_safe_realloc((ptr), (nmemb), (size), (offset)):safe_erealloc((ptr), (nmemb), (size), (offset)))
|
||||
#define perealloc_recoverable(ptr, size, persistent) ((persistent)?realloc((ptr), (size)):erealloc_recoverable((ptr), (size)))
|
||||
#define perealloc2_recoverable(ptr, size, persistent) ((persistent)?realloc((ptr), (size)):erealloc2_recoverable((ptr), (size), (copy_size)))
|
||||
#define pestrdup(s, persistent) ((persistent)?__zend_strdup(s):estrdup(s))
|
||||
#define pestrndup(s, length, persistent) ((persistent)?zend_strndup((s),(length)):estrndup((s),(length)))
|
||||
|
||||
#define pemalloc_rel(size, persistent) ((persistent)?__zend_malloc(size):emalloc_rel(size))
|
||||
#define pemalloc_rel(size, persistent) ((persistent)?__zend_malloc(size ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC):emalloc_rel(size))
|
||||
#define pefree_rel(ptr, persistent) ((persistent)?free(ptr):efree_rel(ptr))
|
||||
#define pecalloc_rel(nmemb, size, persistent) ((persistent)?__zend_calloc((nmemb), (size)):ecalloc_rel((nmemb), (size)))
|
||||
#define perealloc_rel(ptr, size, persistent) ((persistent)?__zend_realloc((ptr), (size)):erealloc_rel((ptr), (size)))
|
||||
#define perealloc2_rel(ptr, size, copy_size, persistent) ((persistent)?__zend_realloc((ptr), (size)):erealloc2_rel((ptr), (size), (copy_size)))
|
||||
#define pecalloc_rel(nmemb, size, persistent) ((persistent)?__zend_calloc((nmemb), (size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC):ecalloc_rel((nmemb), (size)))
|
||||
#define perealloc_rel(ptr, size, persistent) ((persistent)?__zend_realloc((ptr), (size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC):erealloc_rel((ptr), (size)))
|
||||
#define perealloc2_rel(ptr, size, copy_size, persistent) ((persistent)?__zend_realloc((ptr), (size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC):erealloc2_rel((ptr), (size), (copy_size)))
|
||||
#define perealloc_recoverable_rel(ptr, size, persistent) ((persistent)?realloc((ptr), (size)):erealloc_recoverable_rel((ptr), (size)))
|
||||
#define perealloc2_recoverable_rel(ptr, size, copy_size, persistent) ((persistent)?realloc((ptr), (size)):erealloc2_recoverable_rel((ptr), (size), (copy_size)))
|
||||
#define pestrdup_rel(s, persistent) ((persistent)?strdup(s):estrdup_rel(s))
|
||||
|
|
@ -272,20 +273,13 @@ ZEND_API size_t zend_mm_gc(zend_mm_heap *heap);
|
|||
|
||||
ZEND_API bool zend_mm_is_custom_heap(zend_mm_heap *new_heap);
|
||||
ZEND_API void zend_mm_set_custom_handlers(zend_mm_heap *heap,
|
||||
void* (*_malloc)(size_t),
|
||||
void (*_free)(void*),
|
||||
void* (*_realloc)(void*, size_t));
|
||||
ZEND_API void zend_mm_get_custom_handlers(zend_mm_heap *heap,
|
||||
void* (**_malloc)(size_t),
|
||||
void (**_free)(void*),
|
||||
void* (**_realloc)(void*, size_t));
|
||||
|
||||
#if ZEND_DEBUG
|
||||
ZEND_API void zend_mm_set_custom_debug_handlers(zend_mm_heap *heap,
|
||||
void* (*_malloc)(size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC),
|
||||
void (*_free)(void* ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC),
|
||||
void* (*_realloc)(void*, size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC));
|
||||
#endif
|
||||
ZEND_API void zend_mm_get_custom_handlers(zend_mm_heap *heap,
|
||||
void* (**_malloc)(size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC),
|
||||
void (**_free)(void* ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC),
|
||||
void* (**_realloc)(void*, size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC));
|
||||
|
||||
typedef struct _zend_mm_storage zend_mm_storage;
|
||||
|
||||
|
|
|
|||
|
|
@ -643,7 +643,7 @@ static bool has_opline(zend_execute_data *execute_data)
|
|||
;
|
||||
}
|
||||
|
||||
void * zend_test_custom_malloc(size_t len)
|
||||
void * zend_test_custom_malloc(size_t len ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
|
||||
{
|
||||
if (has_opline(EG(current_execute_data))) {
|
||||
assert(EG(current_execute_data)->opline->lineno != (uint32_t)-1);
|
||||
|
|
@ -651,7 +651,7 @@ void * zend_test_custom_malloc(size_t len)
|
|||
return _zend_mm_alloc(ZT_G(zend_orig_heap), len ZEND_FILE_LINE_EMPTY_CC ZEND_FILE_LINE_EMPTY_CC);
|
||||
}
|
||||
|
||||
void zend_test_custom_free(void *ptr)
|
||||
void zend_test_custom_free(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
|
||||
{
|
||||
if (has_opline(EG(current_execute_data))) {
|
||||
assert(EG(current_execute_data)->opline->lineno != (uint32_t)-1);
|
||||
|
|
@ -659,7 +659,7 @@ void zend_test_custom_free(void *ptr)
|
|||
_zend_mm_free(ZT_G(zend_orig_heap), ptr ZEND_FILE_LINE_EMPTY_CC ZEND_FILE_LINE_EMPTY_CC);
|
||||
}
|
||||
|
||||
void * zend_test_custom_realloc(void * ptr, size_t len)
|
||||
void * zend_test_custom_realloc(void * ptr, size_t len ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
|
||||
{
|
||||
if (has_opline(EG(current_execute_data))) {
|
||||
assert(EG(current_execute_data)->opline->lineno != (uint32_t)-1);
|
||||
|
|
|
|||
|
|
@ -1085,7 +1085,7 @@ void phpdbg_free_wrapper(void *p ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) /* {{
|
|||
* let's prevent it from segfault for now
|
||||
*/
|
||||
} else {
|
||||
phpdbg_watch_efree(p);
|
||||
phpdbg_watch_efree(p ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
|
||||
_zend_mm_free(heap, p ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
|
||||
}
|
||||
} /* }}} */
|
||||
|
|
@ -1146,9 +1146,9 @@ int main(int argc, char **argv) /* {{{ */
|
|||
char *read_from_stdin = NULL;
|
||||
zend_string *backup_phpdbg_compile = NULL;
|
||||
bool show_help = 0, show_version = 0;
|
||||
void* (*_malloc)(size_t);
|
||||
void (*_free)(void*);
|
||||
void* (*_realloc)(void*, size_t);
|
||||
void* (*_malloc)(size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
|
||||
void (*_free)(void* ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
|
||||
void* (*_realloc)(void*, size_t ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
|
||||
php_stream_wrapper wrapper;
|
||||
php_stream_wrapper_ops wops;
|
||||
|
||||
|
|
@ -1412,11 +1412,7 @@ phpdbg_main:
|
|||
_free = phpdbg_watch_efree;
|
||||
|
||||
if (use_mm_wrappers) {
|
||||
#if ZEND_DEBUG
|
||||
zend_mm_set_custom_debug_handlers(mm_heap, phpdbg_malloc_wrapper, phpdbg_free_wrapper, phpdbg_realloc_wrapper);
|
||||
#else
|
||||
zend_mm_set_custom_handlers(mm_heap, phpdbg_malloc_wrapper, phpdbg_free_wrapper, phpdbg_realloc_wrapper);
|
||||
#endif
|
||||
} else {
|
||||
zend_mm_set_custom_handlers(mm_heap, _malloc, _free, _realloc);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -256,7 +256,7 @@ ZEND_BEGIN_MODULE_GLOBALS(phpdbg)
|
|||
HashTable *watchlist_mem; /* triggered watchpoints */
|
||||
HashTable *watchlist_mem_backup; /* triggered watchpoints backup table while iterating over it */
|
||||
bool watchpoint_hit; /* a watchpoint was hit */
|
||||
void (*original_free_function)(void *); /* the original AG(mm_heap)->_free function */
|
||||
void (*original_free_function)(void * ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC); /* the original AG(mm_heap)->_free function */
|
||||
phpdbg_watch_element *watch_tmp; /* temporary pointer for a watch element */
|
||||
|
||||
char *exec; /* file to execute */
|
||||
|
|
|
|||
|
|
@ -106,6 +106,7 @@
|
|||
#include "phpdbg_watch.h"
|
||||
#include "phpdbg_utils.h"
|
||||
#include "phpdbg_prompt.h"
|
||||
#include "zend_portability.h"
|
||||
#ifndef _WIN32
|
||||
# include <unistd.h>
|
||||
# include <sys/mman.h>
|
||||
|
|
@ -1195,7 +1196,7 @@ int phpdbg_print_changed_zvals(void) {
|
|||
return ret;
|
||||
}
|
||||
|
||||
void phpdbg_watch_efree(void *ptr) {
|
||||
void phpdbg_watch_efree(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) {
|
||||
phpdbg_btree_result *result;
|
||||
|
||||
/* only do expensive checks if there are any watches at all */
|
||||
|
|
@ -1231,7 +1232,7 @@ void phpdbg_watch_efree(void *ptr) {
|
|||
}
|
||||
|
||||
if (PHPDBG_G(original_free_function)) {
|
||||
PHPDBG_G(original_free_function)(ptr);
|
||||
PHPDBG_G(original_free_function)(ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_ORIG_RELAY_CC);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -130,7 +130,7 @@ int phpdbg_print_changed_zvals(void);
|
|||
|
||||
void phpdbg_list_watchpoints(void);
|
||||
|
||||
void phpdbg_watch_efree(void *ptr);
|
||||
void phpdbg_watch_efree(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
|
||||
|
||||
|
||||
static long phpdbg_pagesize;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue