Revert "Store default object handlers alongside the class entry"

bwoebi · bwoebi · commit 5a0b68bed74e · 2022-09-14T11:18:14.000+02:00
This reverts commit 9e6eab3. Reverted along a01dd9f.
diff --git a/Zend/zend.h b/Zend/zend.h
@@ -182,8 +182,6 @@ 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 */
diff --git a/Zend/zend_API.h b/Zend/zend_API.h
@@ -272,13 +272,11 @@ 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;							\
diff --git a/Zend/zend_attributes.c b/Zend/zend_attributes.c
@@ -131,6 +131,18 @@ 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;
@@ -370,7 +382,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->default_object_handlers = &attributes_object_handlers_sensitive_parameter_value;
+	zend_ce_sensitive_parameter_value->create_object = attributes_sensitive_parameter_value_new;
 }
 
 void zend_attributes_shutdown(void)
diff --git a/Zend/zend_closures.c b/Zend/zend_closures.c
@@ -521,6 +521,7 @@ 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;
 }
@@ -677,7 +678,6 @@ 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;
diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
@@ -1829,7 +1829,6 @@ 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;
diff --git a/Zend/zend_enum.c b/Zend/zend_enum.c
@@ -47,6 +47,8 @@ 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;
 }
 
@@ -182,8 +184,6 @@ 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)
diff --git a/Zend/zend_exceptions.c b/Zend/zend_exceptions.c
@@ -240,19 +240,21 @@ ZEND_API void zend_clear_exception(void) /* {{{ */
 }
 /* }}} */
 
-static zend_object *zend_default_exception_new(zend_class_entry *class_type) /* {{{ */
+static zend_object *zend_default_exception_new_ex(zend_class_entry *class_type, bool skip_top_traces) /* {{{ */
 {
 	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,
-			0,
+			skip_top_traces,
 			EG(exception_ignore_args) ? DEBUG_BACKTRACE_IGNORE_ARGS : 0, 0);
 	} else {
 		array_init(&trace);
@@ -280,6 +282,18 @@ static zend_object *zend_default_exception_new(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)
 {
@@ -725,11 +739,6 @@ 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);
@@ -739,37 +748,37 @@ void zend_register_default_exception(void) /* {{{ */
 	default_exception_handlers.clone_obj = NULL;
 
 	zend_ce_exception = register_class_Exception(zend_ce_throwable);
-	zend_init_exception_class_entry(zend_ce_exception);
+	zend_ce_exception->create_object = zend_default_exception_new;
 
 	zend_ce_error_exception = register_class_ErrorException(zend_ce_exception);
-	zend_init_exception_class_entry(zend_ce_error_exception);
+	zend_ce_error_exception->create_object = zend_error_exception_new;
 
 	zend_ce_error = register_class_Error(zend_ce_throwable);
-	zend_init_exception_class_entry(zend_ce_error);
+	zend_ce_error->create_object = zend_default_exception_new;
 
 	zend_ce_compile_error = register_class_CompileError(zend_ce_error);
-	zend_init_exception_class_entry(zend_ce_compile_error);
+	zend_ce_compile_error->create_object = zend_default_exception_new;
 
 	zend_ce_parse_error = register_class_ParseError(zend_ce_compile_error);
-	zend_init_exception_class_entry(zend_ce_parse_error);
+	zend_ce_parse_error->create_object = zend_default_exception_new;
 
 	zend_ce_type_error = register_class_TypeError(zend_ce_error);
-	zend_init_exception_class_entry(zend_ce_type_error);
+	zend_ce_type_error->create_object = zend_default_exception_new;
 
 	zend_ce_argument_count_error = register_class_ArgumentCountError(zend_ce_type_error);
-	zend_init_exception_class_entry(zend_ce_argument_count_error);
+	zend_ce_argument_count_error->create_object = zend_default_exception_new;
 
 	zend_ce_value_error = register_class_ValueError(zend_ce_error);
-	zend_init_exception_class_entry(zend_ce_value_error);
+	zend_ce_value_error->create_object = zend_default_exception_new;
 
 	zend_ce_arithmetic_error = register_class_ArithmeticError(zend_ce_error);
-	zend_init_exception_class_entry(zend_ce_arithmetic_error);
+	zend_ce_arithmetic_error->create_object = zend_default_exception_new;
 
 	zend_ce_division_by_zero_error = register_class_DivisionByZeroError(zend_ce_arithmetic_error);
-	zend_init_exception_class_entry(zend_ce_division_by_zero_error);
+	zend_ce_division_by_zero_error->create_object = zend_default_exception_new;
 
 	zend_ce_unhandled_match_error = register_class_UnhandledMatchError(zend_ce_error);
-	zend_init_exception_class_entry(zend_ce_unhandled_match_error);
+	zend_ce_unhandled_match_error->create_object = zend_default_exception_new;
 
 	INIT_CLASS_ENTRY(zend_ce_unwind_exit, "UnwindExit", NULL);
 
diff --git a/Zend/zend_fibers.c b/Zend/zend_fibers.c
@@ -589,9 +589,12 @@ 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;
 }
 
@@ -900,7 +903,6 @@ 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;
diff --git a/Zend/zend_generators.c b/Zend/zend_generators.c
@@ -404,7 +404,9 @@ 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 = emalloc(sizeof(zend_generator));
+	zend_generator *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 */
@@ -419,6 +421,8 @@ 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;
 }
 /* }}} */
@@ -1128,7 +1132,6 @@ 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;
diff --git a/Zend/zend_interfaces.c b/Zend/zend_interfaces.c
@@ -480,6 +480,7 @@ 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;
@@ -654,7 +655,6 @@ 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));
diff --git a/Zend/zend_objects.c b/Zend/zend_objects.c
@@ -31,7 +31,6 @@ 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)) {
@@ -187,6 +186,7 @@ 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;
 }
 
diff --git a/Zend/zend_weakrefs.c b/Zend/zend_weakrefs.c
@@ -210,6 +210,9 @@ 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;
 }
 
@@ -301,6 +304,7 @@ 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;
@@ -647,7 +651,6 @@ 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);
@@ -659,7 +662,6 @@ 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);
diff --git a/ext/dom/php_dom.c b/ext/dom/php_dom.c
@@ -782,7 +782,6 @@ 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);
@@ -990,6 +989,7 @@ 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);

Original file line number	Diff line number	Diff line change
`@@ -521,6 +521,7 @@ static zend_object zend_closure_new(zend_class_entry class_type) /* {{{ */`
`521`	`521`	`memset(closure, 0, sizeof(zend_closure));`
`522`	`522`
`523`	`523`	`zend_object_std_init(&closure->std, class_type);`
	`524`	`+ closure->std.handlers = &closure_handlers;`
`524`	`525`
`525`	`526`	`return (zend_object*)closure;`
`526`	`527`	`}`
`@@ -677,7 +678,6 @@ void zend_register_closure_ce(void) /* {{{ */`
`677`	`678`	`{`
`678`	`679`	`zend_ce_closure = register_class_Closure();`
`679`	`680`	`zend_ce_closure->create_object = zend_closure_new;`
`680`		`- zend_ce_closure->default_object_handlers = &closure_handlers;`
`681`	`681`
`682`	`682`	`memcpy(&closure_handlers, &std_object_handlers, sizeof(zend_object_handlers));`
`683`	`683`	`closure_handlers.free_obj = zend_closure_free_storage;`
Original file line number	Diff line number	Diff line change
`@@ -47,6 +47,8 @@ zend_object zend_enum_new(zval result, zend_class_entry ce, zend_string case`
`47`	`47`	`ZVAL_COPY(OBJ_PROP_NUM(zobj, 1), backing_value_zv);`
`48`	`48`	`}`
`49`	`49`
	`50`	`+ zobj->handlers = &enum_handlers;`
	`51`	`+`
`50`	`52`	`return zobj;`
`51`	`53`	`}`
`52`	`54`
`@@ -182,8 +184,6 @@ void zend_enum_add_interfaces(zend_class_entry *ce)`
`182`	`184`	`ce->interface_names[num_interfaces_before + 1].name = zend_string_copy(zend_ce_backed_enum->name);`
`183`	`185`	`ce->interface_names[num_interfaces_before + 1].lc_name = zend_string_init("backedenum", sizeof("backedenum") - 1, 0);`
`184`	`186`	`}`
`185`		`-`
`186`		`- ce->default_object_handlers = &enum_handlers;`
`187`	`187`	`}`
`188`	`188`
`189`	`189`	`zend_result zend_enum_build_backed_enum_table(zend_class_entry *ce)`
Original file line number	Diff line number	Diff line change
`@@ -589,9 +589,12 @@ static zend_always_inline zend_fiber_transfer zend_fiber_suspend(zend_fiber *fib`
`589`	`589`	`static zend_object zend_fiber_object_create(zend_class_entry ce)`
`590`	`590`	`{`
`591`	`591`	`zend_fiber *fiber = emalloc(sizeof(zend_fiber));`
	`592`	`+`
`592`	`593`	`memset(fiber, 0, sizeof(zend_fiber));`
`593`	`594`
`594`	`595`	`zend_object_std_init(&fiber->std, ce);`
	`596`	`+ fiber->std.handlers = &zend_fiber_handlers;`
	`597`	`+`
`595`	`598`	`return &fiber->std;`
`596`	`599`	`}`
`597`	`600`
`@@ -900,7 +903,6 @@ void zend_register_fiber_ce(void)`
`900`	`903`	`{`
`901`	`904`	`zend_ce_fiber = register_class_Fiber();`
`902`	`905`	`zend_ce_fiber->create_object = zend_fiber_object_create;`
`903`		`- zend_ce_fiber->default_object_handlers = &zend_fiber_handlers;`
`904`	`906`
`905`	`907`	`zend_fiber_handlers = std_object_handlers;`
`906`	`908`	`zend_fiber_handlers.dtor_obj = zend_fiber_object_destroy;`