Zy Filemanager

📁 File Browser

Name	Size	Permissions	Actions
📄 zend.h (13,855 bytes)	13.53 KB	0644	✍️ ⬇️ 🗑️
📄 zend_API.h (92,119 bytes)	89.96 KB	0644	✍️ ⬇️ 🗑️
📄 zend_alloc.h (19,293 bytes)	18.84 KB	0644	✍️ ⬇️ 🗑️
📄 zend_alloc_sizes.h (2,629 bytes)	2.57 KB	0644	✍️ ⬇️ 🗑️
📄 zend_arena.h (6,073 bytes)	5.93 KB	0644	✍️ ⬇️ 🗑️
📄 zend_ast.h (12,616 bytes)	12.32 KB	0644	✍️ ⬇️ 🗑️
📄 zend_attributes.h (5,235 bytes)	5.11 KB	0644	✍️ ⬇️ 🗑️
📄 zend_attributes_arginfo.h (503 bytes)	503 B	0644	✍️ ⬇️ 🗑️
📄 zend_bitset.h (7,940 bytes)	7.75 KB	0644	✍️ ⬇️ 🗑️
📄 zend_build.h (1,626 bytes)	1.59 KB	0644	✍️ ⬇️ 🗑️
📄 zend_builtin_functions.h (1,513 bytes)	1.48 KB	0644	✍️ ⬇️ 🗑️
📄 zend_builtin_functions_arginfo.h (13,014 bytes)	12.71 KB	0644	✍️ ⬇️ 🗑️
📄 zend_closures.h (2,216 bytes)	2.16 KB	0644	✍️ ⬇️ 🗑️
📄 zend_closures_arginfo.h (1,751 bytes)	1.71 KB	0644	✍️ ⬇️ 🗑️
📄 zend_compile.h (44,860 bytes)	43.81 KB	0644	✍️ ⬇️ 🗑️
📄 zend_config.h (32 bytes)	32 B	0644	✍️ ⬇️ 🗑️
📄 zend_constants.h (6,485 bytes)	6.33 KB	0644	✍️ ⬇️ 🗑️
📄 zend_cpuinfo.h (7,492 bytes)	7.32 KB	0644	✍️ ⬇️ 🗑️
📄 zend_dtrace.h (2,050 bytes)	2 KB	0644	✍️ ⬇️ 🗑️
📄 zend_errors.h (2,400 bytes)	2.34 KB	0644	✍️ ⬇️ 🗑️
📄 zend_exceptions.h (4,114 bytes)	4.02 KB	0644	✍️ ⬇️ 🗑️
📄 zend_exceptions_arginfo.h (8,098 bytes)	7.91 KB	0644	✍️ ⬇️ 🗑️
📄 zend_execute.h (18,683 bytes)	18.25 KB	0644	✍️ ⬇️ 🗑️
📄 zend_extensions.h (6,194 bytes)	6.05 KB	0644	✍️ ⬇️ 🗑️
📄 zend_float.h (15,438 bytes)	15.08 KB	0644	✍️ ⬇️ 🗑️
📄 zend_gc.h (3,942 bytes)	3.85 KB	0644	✍️ ⬇️ 🗑️
📄 zend_gdb.h (1,420 bytes)	1.39 KB	0644	✍️ ⬇️ 🗑️
📄 zend_generators.h (7,433 bytes)	7.26 KB	0644	✍️ ⬇️ 🗑️
📄 zend_generators_arginfo.h (2,015 bytes)	1.97 KB	0644	✍️ ⬇️ 🗑️
📄 zend_globals.h (8,066 bytes)	7.88 KB	0644	✍️ ⬇️ 🗑️
📄 zend_globals_macros.h (2,810 bytes)	2.74 KB	0644	✍️ ⬇️ 🗑️
📄 zend_hash.h (38,614 bytes)	37.71 KB	0644	✍️ ⬇️ 🗑️
📄 zend_highlight.h (2,289 bytes)	2.24 KB	0644	✍️ ⬇️ 🗑️
📄 zend_inheritance.h (1,967 bytes)	1.92 KB	0644	✍️ ⬇️ 🗑️
📄 zend_ini.h (10,117 bytes)	9.88 KB	0644	✍️ ⬇️ 🗑️
📄 zend_ini_parser.h (2,730 bytes)	2.67 KB	0644	✍️ ⬇️ 🗑️
📄 zend_ini_scanner.h (1,889 bytes)	1.84 KB	0644	✍️ ⬇️ 🗑️
📄 zend_ini_scanner_defs.h (225 bytes)	225 B	0644	✍️ ⬇️ 🗑️
📄 zend_interfaces.h (4,437 bytes)	4.33 KB	0644	✍️ ⬇️ 🗑️
📄 zend_interfaces_arginfo.h (5,287 bytes)	5.16 KB	0644	✍️ ⬇️ 🗑️
📄 zend_istdiostream.h (1,537 bytes)	1.5 KB	0644	✍️ ⬇️ 🗑️
📄 zend_iterators.h (3,581 bytes)	3.5 KB	0644	✍️ ⬇️ 🗑️
📄 zend_language_parser.h (5,960 bytes)	5.82 KB	0644	✍️ ⬇️ 🗑️
📄 zend_language_scanner.h (3,058 bytes)	2.99 KB	0644	✍️ ⬇️ 🗑️
📄 zend_language_scanner_defs.h (310 bytes)	310 B	0644	✍️ ⬇️ 🗑️
📄 zend_list.h (3,475 bytes)	3.39 KB	0644	✍️ ⬇️ 🗑️
📄 zend_llist.h (3,802 bytes)	3.71 KB	0644	✍️ ⬇️ 🗑️
📄 zend_long.h (4,246 bytes)	4.15 KB	0644	✍️ ⬇️ 🗑️
📄 zend_map_ptr.h (3,474 bytes)	3.39 KB	0644	✍️ ⬇️ 🗑️
📄 zend_modules.h (4,830 bytes)	4.72 KB	0644	✍️ ⬇️ 🗑️
📄 zend_multibyte.h (4,897 bytes)	4.78 KB	0644	✍️ ⬇️ 🗑️
📄 zend_multiply.h (9,846 bytes)	9.62 KB	0644	✍️ ⬇️ 🗑️
📄 zend_object_handlers.h (13,854 bytes)	13.53 KB	0644	✍️ ⬇️ 🗑️
📄 zend_objects.h (1,814 bytes)	1.77 KB	0644	✍️ ⬇️ 🗑️
📄 zend_objects_API.h (4,701 bytes)	4.59 KB	0644	✍️ ⬇️ 🗑️
📄 zend_observer.h (3,419 bytes)	3.34 KB	0644	✍️ ⬇️ 🗑️
📄 zend_operators.h (31,181 bytes)	30.45 KB	0644	✍️ ⬇️ 🗑️
📄 zend_portability.h (20,848 bytes)	20.36 KB	0644	✍️ ⬇️ 🗑️
📄 zend_ptr_stack.h (4,306 bytes)	4.21 KB	0644	✍️ ⬇️ 🗑️
📄 zend_range_check.h (3,000 bytes)	2.93 KB	0644	✍️ ⬇️ 🗑️
📄 zend_signal.h (4,084 bytes)	3.99 KB	0644	✍️ ⬇️ 🗑️
📄 zend_smart_str.h (5,378 bytes)	5.25 KB	0644	✍️ ⬇️ 🗑️
📄 zend_smart_str_public.h (1,127 bytes)	1.1 KB	0644	✍️ ⬇️ 🗑️
📄 zend_smart_string.h (4,237 bytes)	4.14 KB	0644	✍️ ⬇️ 🗑️
📄 zend_smart_string_public.h (1,240 bytes)	1.21 KB	0644	✍️ ⬇️ 🗑️
📄 zend_sort.h (1,535 bytes)	1.5 KB	0644	✍️ ⬇️ 🗑️
📄 zend_stack.h (2,364 bytes)	2.31 KB	0644	✍️ ⬇️ 🗑️
📄 zend_stream.h (3,558 bytes)	3.47 KB	0644	✍️ ⬇️ 🗑️
📄 zend_string.h (18,801 bytes)	18.36 KB	0644	✍️ ⬇️ 🗑️
📄 zend_strtod.h (1,854 bytes)	1.81 KB	0644	✍️ ⬇️ 🗑️
📄 zend_strtod_int.h (3,414 bytes)	3.33 KB	0644	✍️ ⬇️ 🗑️
📄 zend_system_id.h (1,404 bytes)	1.37 KB	0644	✍️ ⬇️ 🗑️
📄 zend_ts_hash.h (5,469 bytes)	5.34 KB	0644	✍️ ⬇️ 🗑️
📄 zend_type_info.h (3,755 bytes)	3.67 KB	0644	✍️ ⬇️ 🗑️
📄 zend_types.h (44,902 bytes)	43.85 KB	0644	✍️ ⬇️ 🗑️
📄 zend_variables.h (3,065 bytes)	2.99 KB	0644	✍️ ⬇️ 🗑️
📄 zend_virtual_cwd.h (12,613 bytes)	12.32 KB	0644	✍️ ⬇️ 🗑️
📄 zend_vm.h (1,952 bytes)	1.91 KB	0644	✍️ ⬇️ 🗑️
📄 zend_vm_def.h (279,918 bytes)	273.36 KB	0644	✍️ ⬇️ 🗑️
📄 zend_vm_execute.h (2,073,552 bytes)	1.98 MB	0644	✍️ ⬇️ 🗑️
📄 zend_vm_handlers.h (91,415 bytes)	89.27 KB	0644	✍️ ⬇️ 🗑️
📄 zend_vm_opcodes.h (12,523 bytes)	12.23 KB	0644	✍️ ⬇️ 🗑️
📄 zend_vm_trace_handlers.h (3,212 bytes)	3.14 KB	0644	✍️ ⬇️ 🗑️
📄 zend_vm_trace_lines.h (1,755 bytes)	1.71 KB	0644	✍️ ⬇️ 🗑️
📄 zend_vm_trace_map.h (2,661 bytes)	2.6 KB	0644	✍️ ⬇️ 🗑️
📄 zend_weakrefs.h (1,713 bytes)	1.67 KB	0644	✍️ ⬇️ 🗑️
📄 zend_weakrefs_arginfo.h (2,549 bytes)	2.49 KB	0644	✍️ ⬇️ 🗑️

✍️ Editing: zend_alloc.h

            File: /opt/alt/php80/usr/include/php/Zend/zend_alloc.h

            Size: 18.84 KB | 
            Last Modified: 2026-04-21 02:26:14        

/*
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
   | Copyright (c) Zend Technologies Ltd. (http://www.zend.com)           |
   +----------------------------------------------------------------------+
   | This source file is subject to version 2.00 of the Zend license,     |
   | that is bundled with this package in the file LICENSE, and is        |
   | available through the world-wide-web at the following url:           |
   | http://www.zend.com/license/2_00.txt.                                |
   | If you did not receive a copy of the Zend license and are unable to  |
   | obtain it through the world-wide-web, please send a note to          |
   | license@zend.com so we can mail you a copy immediately.              |
   +----------------------------------------------------------------------+
   | Authors: Andi Gutmans <andi@php.net>                                 |
   |          Zeev Suraski <zeev@php.net>                                 |
   |          Dmitry Stogov <dmitry@php.net>                              |
   +----------------------------------------------------------------------+
*/

#ifndef ZEND_ALLOC_H
#define ZEND_ALLOC_H

#include <stdio.h>

#include "../TSRM/TSRM.h"
#include "zend.h"

#ifndef ZEND_MM_ALIGNMENT
# define ZEND_MM_ALIGNMENT Z_UL(8)
# define ZEND_MM_ALIGNMENT_LOG2 Z_L(3)
#elif ZEND_MM_ALIGNMENT < 4
# undef ZEND_MM_ALIGNMENT
# undef ZEND_MM_ALIGNMENT_LOG2
# define ZEND_MM_ALIGNMENT Z_UL(4)
# define ZEND_MM_ALIGNMENT_LOG2 Z_L(2)
#endif

#define ZEND_MM_ALIGNMENT_MASK ~(ZEND_MM_ALIGNMENT - 1)

#define ZEND_MM_ALIGNED_SIZE(size)	(((size) + ZEND_MM_ALIGNMENT - 1) & ZEND_MM_ALIGNMENT_MASK)

#define ZEND_MM_ALIGNED_SIZE_EX(size, alignment) \
	(((size) + ((alignment) - 1)) & ~((alignment) - 1))

typedef struct _zend_leak_info {
	void *addr;
	size_t size;
	const char *filename;
	const char *orig_filename;
	uint32_t lineno;
	uint32_t orig_lineno;
} zend_leak_info;

#if ZEND_DEBUG
typedef struct _zend_mm_debug_info {
	size_t             size;
	const char        *filename;
	const char        *orig_filename;
	uint32_t               lineno;
	uint32_t               orig_lineno;
} zend_mm_debug_info;

# define ZEND_MM_OVERHEAD ZEND_MM_ALIGNED_SIZE(sizeof(zend_mm_debug_info))
#else
# define ZEND_MM_OVERHEAD 0
#endif

BEGIN_EXTERN_C()

ZEND_API char*  ZEND_FASTCALL zend_strndup(const char *s, size_t length) ZEND_ATTRIBUTE_MALLOC;

ZEND_API void*  ZEND_FASTCALL _emalloc(size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC ZEND_ATTRIBUTE_ALLOC_SIZE(1);
ZEND_API void*  ZEND_FASTCALL _safe_emalloc(size_t nmemb, size_t size, size_t offset ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC;
ZEND_API void*  ZEND_FASTCALL _safe_malloc(size_t nmemb, size_t size, size_t offset) ZEND_ATTRIBUTE_MALLOC;
ZEND_API void   ZEND_FASTCALL _efree(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
ZEND_API void*  ZEND_FASTCALL _ecalloc(size_t nmemb, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC ZEND_ATTRIBUTE_ALLOC_SIZE2(1,2);
ZEND_API void*  ZEND_FASTCALL _erealloc(void *ptr, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_ALLOC_SIZE(2);
ZEND_API void*  ZEND_FASTCALL _erealloc2(void *ptr, size_t size, size_t copy_size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_ALLOC_SIZE(2);
ZEND_API void*  ZEND_FASTCALL _safe_erealloc(void *ptr, size_t nmemb, size_t size, size_t offset ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
ZEND_API void*  ZEND_FASTCALL _safe_realloc(void *ptr, size_t nmemb, size_t size, size_t offset);
ZEND_API char*  ZEND_FASTCALL _estrdup(const char *s ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC;
ZEND_API char*  ZEND_FASTCALL _estrndup(const char *s, size_t length ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC;
ZEND_API size_t ZEND_FASTCALL _zend_mem_block_size(void *ptr ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);

#include "zend_alloc_sizes.h"

/* _emalloc() & _efree() specialization */
#if !ZEND_DEBUG && defined(HAVE_BUILTIN_CONSTANT_P)

# define _ZEND_BIN_ALLOCATOR_DEF(_num, _size, _elements, _pages, x, y) \
	ZEND_API void* ZEND_FASTCALL _emalloc_  ## _size(void) ZEND_ATTRIBUTE_MALLOC;

ZEND_MM_BINS_INFO(_ZEND_BIN_ALLOCATOR_DEF, x, y)

ZEND_API void* ZEND_FASTCALL _emalloc_large(size_t size) ZEND_ATTRIBUTE_MALLOC ZEND_ATTRIBUTE_ALLOC_SIZE(1);
ZEND_API void* ZEND_FASTCALL _emalloc_huge(size_t size) ZEND_ATTRIBUTE_MALLOC ZEND_ATTRIBUTE_ALLOC_SIZE(1);

# define _ZEND_BIN_ALLOCATOR_SELECTOR_START(_num, _size, _elements, _pages, size, y) \
	((size <= _size) ? _emalloc_ ## _size() :
# define _ZEND_BIN_ALLOCATOR_SELECTOR_END(_num, _size, _elements, _pages, size, y) \
	)

# define ZEND_ALLOCATOR(size) \
	ZEND_MM_BINS_INFO(_ZEND_BIN_ALLOCATOR_SELECTOR_START, size, y) \
	((size <= ZEND_MM_MAX_LARGE_SIZE) ? _emalloc_large(size) : _emalloc_huge(size)) \
	ZEND_MM_BINS_INFO(_ZEND_BIN_ALLOCATOR_SELECTOR_END, size, y)

# define _emalloc(size) \
	(__builtin_constant_p(size) ? \
		ZEND_ALLOCATOR(size) \
	: \
		_emalloc(size) \
	)

# define _ZEND_BIN_DEALLOCATOR_DEF(_num, _size, _elements, _pages, x, y) \
	ZEND_API void ZEND_FASTCALL _efree_ ## _size(void *);

ZEND_MM_BINS_INFO(_ZEND_BIN_DEALLOCATOR_DEF, x, y)

ZEND_API void ZEND_FASTCALL _efree_large(void *, size_t size);
ZEND_API void ZEND_FASTCALL _efree_huge(void *, size_t size);

# define _ZEND_BIN_DEALLOCATOR_SELECTOR_START(_num, _size, _elements, _pages, ptr, size) \
	if (size <= _size) { _efree_ ## _size(ptr); } else

# define ZEND_DEALLOCATOR(ptr, size) \
	ZEND_MM_BINS_INFO(_ZEND_BIN_DEALLOCATOR_SELECTOR_START, ptr, size) \
	if (size <= ZEND_MM_MAX_LARGE_SIZE) { _efree_large(ptr, size); } \
	else { _efree_huge(ptr, size); }

# define efree_size(ptr, size) do { \
		if (__builtin_constant_p(size)) { \
			ZEND_DEALLOCATOR(ptr, size) \
		} else { \
			_efree(ptr); \
		} \
	} while (0)
# define efree_size_rel(ptr, size) \
	efree_size(ptr, size)

#else

# define efree_size(ptr, size) \
	efree(ptr)
# define efree_size_rel(ptr, size) \
	efree_rel(ptr)

#define _emalloc_large _emalloc
#define _emalloc_huge  _emalloc
#define _efree_large   _efree
#define _efree_huge    _efree

#endif

/* Standard wrapper macros */
#define emalloc(size)						_emalloc((size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define emalloc_large(size)					_emalloc_large((size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define emalloc_huge(size)					_emalloc_huge((size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define safe_emalloc(nmemb, size, offset)	_safe_emalloc((nmemb), (size), (offset) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define efree(ptr)							_efree((ptr) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define efree_large(ptr)					_efree_large((ptr) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define efree_huge(ptr)						_efree_huge((ptr) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define ecalloc(nmemb, size)				_ecalloc((nmemb), (size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define erealloc(ptr, size)					_erealloc((ptr), (size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define erealloc2(ptr, size, copy_size)		_erealloc2((ptr), (size), (copy_size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define safe_erealloc(ptr, nmemb, size, offset)	_safe_erealloc((ptr), (nmemb), (size), (offset) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define erealloc_recoverable(ptr, size)		_erealloc((ptr), (size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define erealloc2_recoverable(ptr, size, copy_size) _erealloc2((ptr), (size), (copy_size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define estrdup(s)							_estrdup((s) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define estrndup(s, length)					_estrndup((s), (length) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define zend_mem_block_size(ptr)			_zend_mem_block_size((ptr) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)

/* Relay wrapper macros */
#define emalloc_rel(size)						_emalloc((size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
#define safe_emalloc_rel(nmemb, size, offset)	_safe_emalloc((nmemb), (size), (offset) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
#define efree_rel(ptr)							_efree((ptr) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
#define ecalloc_rel(nmemb, size)				_ecalloc((nmemb), (size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
#define erealloc_rel(ptr, size)					_erealloc((ptr), (size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
#define erealloc2_rel(ptr, size, copy_size)		_erealloc2((ptr), (size), (copy_size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
#define erealloc_recoverable_rel(ptr, size)		_erealloc((ptr), (size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
#define erealloc2_recoverable_rel(ptr, size, copy_size) _erealloc2((ptr), (size), (copy_size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
#define safe_erealloc_rel(ptr, nmemb, size, offset)	_safe_erealloc((ptr), (nmemb), (size), (offset) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
#define estrdup_rel(s)							_estrdup((s) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
#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 void * __zend_malloc(size_t len) ZEND_ATTRIBUTE_MALLOC ZEND_ATTRIBUTE_ALLOC_SIZE(1);
ZEND_API void * __zend_calloc(size_t nmemb, size_t len) ZEND_ATTRIBUTE_MALLOC ZEND_ATTRIBUTE_ALLOC_SIZE2(1,2);
ZEND_API void * __zend_realloc(void *p, size_t len) ZEND_ATTRIBUTE_ALLOC_SIZE(2);

/* Selective persistent/non persistent allocation macros */
#define pemalloc(size, persistent) ((persistent)?__zend_malloc(size):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 { \
		if (persistent) { \
			free(ptr); \
		} else { \
			efree_size(ptr, size);\
		} \
	} 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 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)?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 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 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))

ZEND_API void zend_set_memory_limit(size_t memory_limit);
ZEND_API zend_result zend_set_memory_limit_ex(size_t memory_limit);

ZEND_API void start_memory_manager(void);
ZEND_API void shutdown_memory_manager(bool silent, bool full_shutdown);
ZEND_API bool is_zend_mm(void);
ZEND_API bool is_zend_ptr(const void *ptr);

ZEND_API size_t zend_memory_usage(bool real_usage);
ZEND_API size_t zend_memory_peak_usage(bool real_usage);

/* fast cache for HashTables */
#define ALLOC_HASHTABLE(ht)	\
	(ht) = (HashTable *) emalloc(sizeof(HashTable))

#define FREE_HASHTABLE(ht)	\
	efree_size(ht, sizeof(HashTable))

#define ALLOC_HASHTABLE_REL(ht)	\
	(ht) = (HashTable *) emalloc_rel(sizeof(HashTable))

#define FREE_HASHTABLE_REL(ht)	\
	efree_size_rel(ht, sizeof(HashTable))

/* Heap functions */
typedef struct _zend_mm_heap zend_mm_heap;

ZEND_API zend_mm_heap *zend_mm_startup(void);
ZEND_API void zend_mm_shutdown(zend_mm_heap *heap, bool full_shutdown, bool silent);
ZEND_API void*  ZEND_FASTCALL _zend_mm_alloc(zend_mm_heap *heap, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC) ZEND_ATTRIBUTE_MALLOC;
ZEND_API void   ZEND_FASTCALL _zend_mm_free(zend_mm_heap *heap, void *p ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
ZEND_API void*  ZEND_FASTCALL _zend_mm_realloc(zend_mm_heap *heap, void *p, size_t size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
ZEND_API void*  ZEND_FASTCALL _zend_mm_realloc2(zend_mm_heap *heap, void *p, size_t size, size_t copy_size ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);
ZEND_API size_t ZEND_FASTCALL _zend_mm_block_size(zend_mm_heap *heap, void *p ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC);

#define zend_mm_alloc(heap, size)			_zend_mm_alloc((heap), (size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define zend_mm_free(heap, p)				_zend_mm_free((heap), (p) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define zend_mm_realloc(heap, p, size)		_zend_mm_realloc((heap), (p), (size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define zend_mm_realloc2(heap, p, size, copy_size) _zend_mm_realloc2((heap), (p), (size), (copy_size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
#define zend_mm_block_size(heap, p)			_zend_mm_block_size((heap), (p) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)

#define zend_mm_alloc_rel(heap, size)		_zend_mm_alloc((heap), (size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
#define zend_mm_free_rel(heap, p)			_zend_mm_free((heap), (p) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
#define zend_mm_realloc_rel(heap, p, size)	_zend_mm_realloc((heap), (p), (size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
#define zend_mm_realloc2_rel(heap, p, size, copy_size) _zend_mm_realloc2((heap), (p), (size), (copy_size) ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC)
#define zend_mm_block_size_rel(heap, p)		_zend_mm_block_size((heap), (p) ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)

ZEND_API zend_mm_heap *zend_mm_set_heap(zend_mm_heap *new_heap);
ZEND_API zend_mm_heap *zend_mm_get_heap(void);

ZEND_API size_t zend_mm_gc(zend_mm_heap *heap);

#define ZEND_MM_CUSTOM_HEAP_NONE  0
#define ZEND_MM_CUSTOM_HEAP_STD   1
#define ZEND_MM_CUSTOM_HEAP_DEBUG 2

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

typedef struct _zend_mm_storage zend_mm_storage;

typedef	void* (*zend_mm_chunk_alloc_t)(zend_mm_storage *storage, size_t size, size_t alignment);
typedef void  (*zend_mm_chunk_free_t)(zend_mm_storage *storage, void *chunk, size_t size);
typedef bool   (*zend_mm_chunk_truncate_t)(zend_mm_storage *storage, void *chunk, size_t old_size, size_t new_size);
typedef bool   (*zend_mm_chunk_extend_t)(zend_mm_storage *storage, void *chunk, size_t old_size, size_t new_size);

typedef struct _zend_mm_handlers {
	zend_mm_chunk_alloc_t       chunk_alloc;
	zend_mm_chunk_free_t        chunk_free;
	zend_mm_chunk_truncate_t    chunk_truncate;
	zend_mm_chunk_extend_t      chunk_extend;
} zend_mm_handlers;

struct _zend_mm_storage {
	const zend_mm_handlers handlers;
	void *data;
};

ZEND_API zend_mm_storage *zend_mm_get_storage(zend_mm_heap *heap);
ZEND_API zend_mm_heap *zend_mm_startup_ex(const zend_mm_handlers *handlers, void *data, size_t data_size);

// The following example shows how to use zend_mm_heap API with custom storage

static zend_mm_heap *apc_heap = NULL;
static HashTable    *apc_ht = NULL;

typedef struct _apc_data {
	void     *mem;
	uint32_t  free_pages;
} apc_data;

static void *apc_chunk_alloc(zend_mm_storage *storage, size_t size, size_t alignment)
{
	apc_data *data = (apc_data*)(storage->data);
	size_t real_size = ((size + (ZEND_MM_CHUNK_SIZE-1)) & ~(ZEND_MM_CHUNK_SIZE-1));
	uint32_t count = real_size / ZEND_MM_CHUNK_SIZE;
	uint32_t first, last, i;

ZEND_ASSERT(alignment == ZEND_MM_CHUNK_SIZE);

for (first = 0; first < 32; first++) {
		if (!(data->free_pages & (1 << first))) {
			last = first;
			do {
				if (last - first == count - 1) {
					for (i = first; i <= last; i++) {
						data->free_pages |= (1 << i);
					}
					return (void *)(((char*)(data->mem)) + ZEND_MM_CHUNK_SIZE * (1 << first));
				}
				last++;
			} while (last < 32 && !(data->free_pages & (1 << last)));
			first = last;
		}
	}
	return NULL;
}

static void apc_chunk_free(zend_mm_storage *storage, void *chunk, size_t size)
{
	apc_data *data = (apc_data*)(storage->data);
	uint32_t i;

ZEND_ASSERT(((uintptr_t)chunk & (ZEND_MM_CHUNK_SIZE - 1)) == 0);

i = ((uintptr_t)chunk - (uintptr_t)(data->mem)) / ZEND_MM_CHUNK_SIZE;
	while (1) {
		data->free_pages &= ~(1 << i);
		if (size <= ZEND_MM_CHUNK_SIZE) {
			break;
		}
		size -= ZEND_MM_CHUNK_SIZE;
	}
}

static void apc_init_heap(void)
{
	zend_mm_handlers apc_handlers = {
		apc_chunk_alloc,
		apc_chunk_free,
		NULL,
		NULL,
	};
	apc_data tmp_data;
	zend_mm_heap *old_heap;

// Preallocate properly aligned SHM chunks (64MB)
	tmp_data.mem = shm_memalign(ZEND_MM_CHUNK_SIZE, ZEND_MM_CHUNK_SIZE * 32);

// Initialize temporary storage data
	tmp_data.free_pages = 0;

// Create heap
	apc_heap = zend_mm_startup_ex(&apc_handlers, &tmp_data, sizeof(tmp_data));

// Allocate some data in the heap
	old_heap = zend_mm_set_heap(apc_heap);
	ALLOC_HASHTABLE(apc_ht);
	zend_hash_init(apc_ht, 64, NULL, ZVAL_PTR_DTOR, 0);
	zend_mm_set_heap(old_heap);
}

#ifdef ZTS
size_t zend_mm_globals_size(void);
#endif

END_EXTERN_C()

#endif

↩️ Back

Zy Filemanager

📁 File Browser

📤 Upload Files

Single File

Multiple Files

ZIP Extract

➕ Create New

New Folder

New File

✍️ Editing: zend_alloc.h

Backup Management