Store default object handlers alongside the class entry

Object handlers being separate from class entries is a legacy inherited from PHP 5. Today it has little benefit to keep them separate: in fact, accessing object handlers usually requires not-so-safe hacks.
While it is possible to swap handlers in a custom installed create_object handler, this mostly is tedious, as well as it requires allocating the object handlers struct at runtime, possibly caching it etc..

This allows extensions, which intend to observe other classes to install their own class handlers.
The life cycle of internal classes may now be simply observed by swapping the class handlers in post_startup stage.
The life cycle of userland classes may be observed by iterating over the new classes in zend_compile_file and zend_compile_string and then swapping their handlers.

In general, this would also be a first step in directly tying the object handlers to classes. Especially given that I am not aware of any case where the object handlers would be different between various instances of a given class.

Signed-off-by: Bob Weinand <[email protected]>

Author: bwoebi

Zend/zend.h

@@ -182,6 +182,8 @@ struct _zend_class_entry {
 	zend_function *__serialize;
 	zend_function *__unserialize;
 
+	const zend_object_handlers *default_object_handlers;
+
 	/* allocated only if class implements Iterator or IteratorAggregate interface */
 	zend_class_iterator_funcs *iterator_funcs_ptr;
 	/* allocated only if class implements ArrayAccess interface */

Zend/zend_API.h

@@ -272,11 +272,13 @@ typedef struct _zend_fcall_info_cache {
 	{															\
 		memset(&class_container, 0, sizeof(zend_class_entry)); \
 		class_container.name = zend_string_init_interned(class_name, class_name_len, 1); \
+		class_container.default_object_handlers = &std_object_handlers;	\
 		class_container.info.internal.builtin_functions = functions;	\
 	}
 
 #define INIT_CLASS_ENTRY_INIT_METHODS(class_container, functions) \
 	{															\
+		class_container.default_object_handlers = &std_object_handlers;	\
 		class_container.constructor = NULL;						\
 		class_container.destructor = NULL;						\
 		class_container.clone = NULL;							\

Zend/zend_attributes.c

@@ -131,18 +131,6 @@ ZEND_METHOD(SensitiveParameterValue, __debugInfo)
 	RETURN_EMPTY_ARRAY();
 }
 
-static zend_object *attributes_sensitive_parameter_value_new(zend_class_entry *ce)
-{
-	zend_object *object;
-
-	object = zend_objects_new(ce);
-	object->handlers = &attributes_object_handlers_sensitive_parameter_value;
-
-	object_properties_init(object, ce);
-
-	return object;
-}
-
 static HashTable *attributes_sensitive_parameter_value_get_properties_for(zend_object *zobj, zend_prop_purpose purpose)
 {
 	return NULL;
@@ -382,7 +370,7 @@ void zend_register_attribute_ce(void)
 
 	/* This is not an actual attribute, thus the zend_mark_internal_attribute() call is missing. */
 	zend_ce_sensitive_parameter_value = register_class_SensitiveParameterValue();
-	zend_ce_sensitive_parameter_value->create_object = attributes_sensitive_parameter_value_new;
+	zend_ce_sensitive_parameter_value->default_object_handlers = &attributes_object_handlers_sensitive_parameter_value;
 }
 
 void zend_attributes_shutdown(void)

Zend/zend_closures.c

@@ -521,7 +521,6 @@ static zend_object *zend_closure_new(zend_class_entry *class_type) /* {{{ */
 	memset(closure, 0, sizeof(zend_closure));
 
 	zend_object_std_init(&closure->std, class_type);
-	closure->std.handlers = &closure_handlers;
 
 	return (zend_object*)closure;
 }
@@ -678,6 +677,7 @@ void zend_register_closure_ce(void) /* {{{ */
 {
 	zend_ce_closure = register_class_Closure();
 	zend_ce_closure->create_object = zend_closure_new;
+	zend_ce_closure->default_object_handlers = &closure_handlers;
 
 	memcpy(&closure_handlers, &std_object_handlers, sizeof(zend_object_handlers));
 	closure_handlers.free_obj = zend_closure_free_storage;

Zend/zend_compile.c

@@ -1828,6 +1828,7 @@ ZEND_API void zend_initialize_class_data(zend_class_entry *ce, bool nullify_hand
 	ZEND_MAP_PTR_INIT(ce->static_members_table, NULL);
 	ZEND_MAP_PTR_INIT(ce->mutable_data, NULL);
 
+	ce->default_object_handlers = &std_object_handlers;
 	ce->default_properties_count = 0;
 	ce->default_static_members_count = 0;
 	ce->properties_info_table = NULL;

Zend/zend_enum.c

@@ -47,8 +47,6 @@ zend_object *zend_enum_new(zval *result, zend_class_entry *ce, zend_string *case
 		ZVAL_COPY(OBJ_PROP_NUM(zobj, 1), backing_value_zv);
 	}
 
-	zobj->handlers = &enum_handlers;
-
 	return zobj;
 }
 
@@ -184,6 +182,8 @@ void zend_enum_add_interfaces(zend_class_entry *ce)
 		ce->interface_names[num_interfaces_before + 1].name = zend_string_copy(zend_ce_backed_enum->name);
 		ce->interface_names[num_interfaces_before + 1].lc_name = zend_string_init("backedenum", sizeof("backedenum") - 1, 0);	
 	}
+
+	ce->default_object_handlers = &enum_handlers;
 }
 
 zend_result zend_enum_build_backed_enum_table(zend_class_entry *ce)

Zend/zend_exceptions.c

@@ -240,21 +240,19 @@ ZEND_API void zend_clear_exception(void) /* {{{ */
 }
 /* }}} */
 
-static zend_object *zend_default_exception_new_ex(zend_class_entry *class_type, bool skip_top_traces) /* {{{ */
+static zend_object *zend_default_exception_new(zend_class_entry *class_type) /* {{{ */
 {
 	zval tmp;
 	zval trace;
 	zend_class_entry *base_ce;
 	zend_string *filename;
 
 	zend_object *object = zend_objects_new(class_type);
-	object->handlers = &default_exception_handlers;
-
 	object_properties_init(object, class_type);
 
 	if (EG(current_execute_data)) {
 		zend_fetch_debug_backtrace(&trace,
-			skip_top_traces,
+			0,
 			EG(exception_ignore_args) ? DEBUG_BACKTRACE_IGNORE_ARGS : 0, 0);
 	} else {
 		array_init(&trace);
@@ -282,18 +280,6 @@ static zend_object *zend_default_exception_new_ex(zend_class_entry *class_type,
 }
 /* }}} */
 
-static zend_object *zend_default_exception_new(zend_class_entry *class_type) /* {{{ */
-{
-	return zend_default_exception_new_ex(class_type, 0);
-}
-/* }}} */
-
-static zend_object *zend_error_exception_new(zend_class_entry *class_type) /* {{{ */
-{
-	return zend_default_exception_new_ex(class_type, 0);
-}
-/* }}} */
-
 /* {{{ Clone the exception object */
 ZEND_COLD ZEND_METHOD(Exception, __clone)
 {
@@ -739,6 +725,11 @@ ZEND_METHOD(Exception, __toString)
 }
 /* }}} */
 
+static void zend_init_exception_class_entry(zend_class_entry *ce) {
+	ce->create_object = zend_default_exception_new;
+	ce->default_object_handlers = &default_exception_handlers;
+}
+
 void zend_register_default_exception(void) /* {{{ */
 {
 	zend_ce_throwable = register_class_Throwable(zend_ce_stringable);
@@ -748,37 +739,37 @@ void zend_register_default_exception(void) /* {{{ */
 	default_exception_handlers.clone_obj = NULL;
 
 	zend_ce_exception = register_class_Exception(zend_ce_throwable);
-	zend_ce_exception->create_object = zend_default_exception_new;
+	zend_init_exception_class_entry(zend_ce_exception);
 
 	zend_ce_error_exception = register_class_ErrorException(zend_ce_exception);
-	zend_ce_error_exception->create_object = zend_error_exception_new;
+	zend_init_exception_class_entry(zend_ce_error_exception);
 
 	zend_ce_error = register_class_Error(zend_ce_throwable);
-	zend_ce_error->create_object = zend_default_exception_new;
+	zend_init_exception_class_entry(zend_ce_error);
 
 	zend_ce_compile_error = register_class_CompileError(zend_ce_error);
-	zend_ce_compile_error->create_object = zend_default_exception_new;
+	zend_init_exception_class_entry(zend_ce_compile_error);
 
 	zend_ce_parse_error = register_class_ParseError(zend_ce_compile_error);
-	zend_ce_parse_error->create_object = zend_default_exception_new;
+	zend_init_exception_class_entry(zend_ce_parse_error);
 
 	zend_ce_type_error = register_class_TypeError(zend_ce_error);
-	zend_ce_type_error->create_object = zend_default_exception_new;
+	zend_init_exception_class_entry(zend_ce_type_error);
 
 	zend_ce_argument_count_error = register_class_ArgumentCountError(zend_ce_type_error);
-	zend_ce_argument_count_error->create_object = zend_default_exception_new;
+	zend_init_exception_class_entry(zend_ce_argument_count_error);
 
 	zend_ce_value_error = register_class_ValueError(zend_ce_error);
-	zend_ce_value_error->create_object = zend_default_exception_new;
+	zend_init_exception_class_entry(zend_ce_value_error);
 
 	zend_ce_arithmetic_error = register_class_ArithmeticError(zend_ce_error);
-	zend_ce_arithmetic_error->create_object = zend_default_exception_new;
+	zend_init_exception_class_entry(zend_ce_arithmetic_error);
 
 	zend_ce_division_by_zero_error = register_class_DivisionByZeroError(zend_ce_arithmetic_error);
-	zend_ce_division_by_zero_error->create_object = zend_default_exception_new;
+	zend_init_exception_class_entry(zend_ce_division_by_zero_error);
 
 	zend_ce_unhandled_match_error = register_class_UnhandledMatchError(zend_ce_error);
-	zend_ce_unhandled_match_error->create_object = zend_default_exception_new;
+	zend_init_exception_class_entry(zend_ce_unhandled_match_error);
 
 	INIT_CLASS_ENTRY(zend_ce_unwind_exit, "UnwindExit", NULL);
 

Zend/zend_fibers.c

@@ -589,12 +589,9 @@ static zend_always_inline zend_fiber_transfer zend_fiber_suspend(zend_fiber *fib
 static zend_object *zend_fiber_object_create(zend_class_entry *ce)
 {
 	zend_fiber *fiber = emalloc(sizeof(zend_fiber));
-
 	memset(fiber, 0, sizeof(zend_fiber));
 
 	zend_object_std_init(&fiber->std, ce);
-	fiber->std.handlers = &zend_fiber_handlers;
-
 	return &fiber->std;
 }
 
@@ -903,6 +900,7 @@ void zend_register_fiber_ce(void)
 {
 	zend_ce_fiber = register_class_Fiber();
 	zend_ce_fiber->create_object = zend_fiber_object_create;
+	zend_ce_fiber->default_object_handlers = &zend_fiber_handlers;
 
 	zend_fiber_handlers = std_object_handlers;
 	zend_fiber_handlers.dtor_obj = zend_fiber_object_destroy;

Zend/zend_generators.c

@@ -404,9 +404,7 @@ static HashTable *zend_generator_get_gc(zend_object *object, zval **table, int *
 
 static zend_object *zend_generator_create(zend_class_entry *class_type) /* {{{ */
 {
-	zend_generator *generator;
-
-	generator = emalloc(sizeof(zend_generator));
+	zend_generator *generator = emalloc(sizeof(zend_generator));
 	memset(generator, 0, sizeof(zend_generator));
 
 	/* The key will be incremented on first use, so it'll start at 0 */
@@ -421,8 +419,6 @@ static zend_object *zend_generator_create(zend_class_entry *class_type) /* {{{ *
 	generator->node.ptr.root = NULL;
 
 	zend_object_std_init(&generator->std, class_type);
-	generator->std.handlers = &zend_generator_handlers;
-
 	return (zend_object*)generator;
 }
 /* }}} */
@@ -1132,6 +1128,7 @@ void zend_register_generator_ce(void) /* {{{ */
 	zend_ce_generator->create_object = zend_generator_create;
 	/* get_iterator has to be assigned *after* implementing the interface */
 	zend_ce_generator->get_iterator = zend_generator_get_iterator;
+	zend_ce_generator->default_object_handlers = &zend_generator_handlers;
 
 	memcpy(&zend_generator_handlers, &std_object_handlers, sizeof(zend_object_handlers));
 	zend_generator_handlers.free_obj = zend_generator_free_storage;

Zend/zend_interfaces.c

@@ -480,7 +480,6 @@ typedef struct {
 static zend_object *zend_internal_iterator_create(zend_class_entry *ce) {
 	zend_internal_iterator *intern = emalloc(sizeof(zend_internal_iterator));
 	zend_object_std_init(&intern->std, ce);
-	intern->std.handlers = &zend_internal_iterator_handlers;
 	intern->iter = NULL;
 	intern->rewind_called = 0;
 	return &intern->std;
@@ -655,6 +654,7 @@ ZEND_API void zend_register_interfaces(void)
 
 	zend_ce_internal_iterator = register_class_InternalIterator(zend_ce_iterator);
 	zend_ce_internal_iterator->create_object = zend_internal_iterator_create;
+	zend_ce_internal_iterator->default_object_handlers = &zend_internal_iterator_handlers;
 
 	memcpy(&zend_internal_iterator_handlers, zend_get_std_object_handlers(),
 		sizeof(zend_object_handlers));

Zend/zend_objects.c

@@ -31,6 +31,7 @@ static zend_always_inline void _zend_object_std_init(zend_object *object, zend_c
 	GC_SET_REFCOUNT(object, 1);
 	GC_TYPE_INFO(object) = GC_OBJECT;
 	object->ce = ce;
+	object->handlers = ce->default_object_handlers;
 	object->properties = NULL;
 	zend_objects_store_put(object);
 	if (UNEXPECTED(ce->ce_flags & ZEND_ACC_USE_GUARDS)) {
@@ -186,7 +187,6 @@ ZEND_API zend_object* ZEND_FASTCALL zend_objects_new(zend_class_entry *ce)
 	zend_object *object = emalloc(sizeof(zend_object) + zend_object_properties_size(ce));
 
 	_zend_object_std_init(object, ce);
-	object->handlers = &std_object_handlers;
 	return object;
 }
 

Zend/zend_weakrefs.c

@@ -210,9 +210,6 @@ static zend_object* zend_weakref_new(zend_class_entry *ce) {
 	zend_weakref *wr = zend_object_alloc(sizeof(zend_weakref), zend_ce_weakref);
 
 	zend_object_std_init(&wr->std, zend_ce_weakref);
-
-	wr->std.handlers = &zend_weakref_handlers;
-
 	return &wr->std;
 }
 
@@ -304,7 +301,6 @@ static zend_object *zend_weakmap_create_object(zend_class_entry *ce)
 {
 	zend_weakmap *wm = zend_object_alloc(sizeof(zend_weakmap), ce);
 	zend_object_std_init(&wm->std, ce);
-	wm->std.handlers = &zend_weakmap_handlers;
 
 	zend_hash_init(&wm->ht, 0, NULL, ZVAL_PTR_DTOR, 0);
 	return &wm->std;
@@ -651,6 +647,7 @@ void zend_register_weakref_ce(void) /* {{{ */
 	zend_ce_weakref = register_class_WeakReference();
 
 	zend_ce_weakref->create_object = zend_weakref_new;
+	zend_ce_weakref->default_object_handlers = &zend_weakref_handlers;
 
 	memcpy(&zend_weakref_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 	zend_weakref_handlers.offset = XtOffsetOf(zend_weakref, std);
@@ -662,6 +659,7 @@ void zend_register_weakref_ce(void) /* {{{ */
 
 	zend_ce_weakmap->create_object = zend_weakmap_create_object;
 	zend_ce_weakmap->get_iterator = zend_weakmap_get_iterator;
+	zend_ce_weakmap->default_object_handlers = &zend_weakmap_handlers;
 
 	memcpy(&zend_weakmap_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 	zend_weakmap_handlers.offset = XtOffsetOf(zend_weakmap, std);

ext/dom/php_dom.c

@@ -782,6 +782,7 @@ PHP_MINIT_FUNCTION(dom)
 
 	dom_xpath_class_entry = register_class_DOMXPath();
 	dom_xpath_class_entry->create_object = dom_xpath_objects_new;
+	dom_xpath_class_entry->default_object_handlers = &dom_xpath_object_handlers;
 
 	zend_hash_init(&dom_xpath_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
 	dom_register_prop_handler(&dom_xpath_prop_handlers, "document", sizeof("document")-1, dom_xpath_document_read, NULL);
@@ -989,7 +990,6 @@ zend_object *dom_xpath_objects_new(zend_class_entry *class_type)
 	intern->register_node_ns = 1;
 
 	intern->dom.prop_handler = &dom_xpath_prop_handlers;
-	intern->dom.std.handlers = &dom_xpath_object_handlers;
 
 	zend_object_std_init(&intern->dom.std, class_type);
 	object_properties_init(&intern->dom.std, class_type);