fix(opcache): persist substituted property hooks and skip SHM destroy

Signed-off-by: azjezz <azjezz@protonmail.com>

Author: azjezz

Zend/Optimizer/zend_optimizer.c

@@ -1748,6 +1748,34 @@ ZEND_API void zend_optimize_script(zend_script *script, zend_long optimization_l
 				}
 			}
 		} ZEND_HASH_FOREACH_END();
+
+		zend_property_info *prop;
+		ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&ce->properties_info, name, prop) {
+			if (prop->ce == ce || !prop->hooks) {
+				continue;
+			}
+
+			const zend_property_info *parent_prop = zend_hash_find_ptr(&prop->ce->properties_info, name);
+			if (!parent_prop || parent_prop == prop || !parent_prop->hooks) {
+				continue;
+			}
+
+			for (uint32_t hi = 0; hi < ZEND_PROPERTY_HOOK_COUNT; hi++) {
+				zend_function *clone_hook = prop->hooks[hi];
+				zend_function *parent_hook = parent_prop->hooks[hi];
+				if (!clone_hook || !parent_hook || clone_hook == parent_hook) {
+					continue;
+				}
+
+				zend_arg_info *arg_info = clone_hook->op_array.arg_info;
+				bool arg_info_substituted = (arg_info != parent_hook->op_array.arg_info);
+
+				clone_hook->op_array = parent_hook->op_array;
+				if (arg_info_substituted) {
+					clone_hook->op_array.arg_info = arg_info;
+				}
+			}
+		} ZEND_HASH_FOREACH_END();
 	} ZEND_HASH_FOREACH_END();
 
 	zend_optimizer_call_registered_passes(script, &ctx);

Zend/zend_opcode.c

@@ -188,6 +188,22 @@ ZEND_API void zend_generic_type_table_destroy(zend_generic_type_table *table) {
 	if (!table) {
 		return;
 	}
+
+	bool persisted = false;
+#define MAYBE_PERSISTED(ht) ((ht) && (GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE))
+	if (MAYBE_PERSISTED(table->parameters)
+	  || MAYBE_PERSISTED(table->properties)
+	  || MAYBE_PERSISTED(table->class_constants)
+	  || MAYBE_PERSISTED(table->implements)
+	  || MAYBE_PERSISTED(table->trait_uses)
+	  || MAYBE_PERSISTED(table->turbofish_args)) {
+		persisted = true;
+	}
+#undef MAYBE_PERSISTED
+	if (persisted) {
+		return;
+	}
+
 	if (table->return_type) {
 		zend_type_release(*table->return_type, /* persistent */ false);
 		efree(table->return_type);

ext/opcache/zend_persist.c

@@ -1028,6 +1028,41 @@ static zend_property_info *zend_persist_property_info(zend_property_info *prop)
 	return prop;
 }
 
+static zend_property_info *zend_persist_substituted_property_info(zend_property_info *prop)
+{
+	zend_class_entry *ce;
+	prop = zend_shared_memdup_put(prop, sizeof(zend_property_info));
+	ce = zend_shared_alloc_get_xlat_entry(prop->ce);
+	if (ce) {
+		prop->ce = ce;
+	}
+
+	if (prop->prototype) {
+		const zend_property_info *xlat_proto = zend_shared_alloc_get_xlat_entry(prop->prototype);
+		if (xlat_proto) {
+			prop->prototype = xlat_proto;
+		}
+	}
+
+	zend_persist_type(&prop->type);
+	if (prop->hooks) {
+		prop->hooks = zend_shared_memdup_put(prop->hooks, ZEND_PROPERTY_HOOK_STRUCT_SIZE);
+		for (uint32_t i = 0; i < ZEND_PROPERTY_HOOK_COUNT; i++) {
+			if (prop->hooks[i]) {
+				zend_op_array *hook = zend_persist_class_method(&prop->hooks[i]->op_array, prop->ce);
+				const zend_property_info *new_prop_info = zend_shared_alloc_get_xlat_entry(hook->prop_info);
+				if (new_prop_info) {
+					hook->prop_info = new_prop_info;
+				}
+
+				prop->hooks[i] = (zend_function *) hook;
+			}
+		}
+	}
+
+	return prop;
+}
+
 static void zend_persist_class_constant(zval *zv)
 {
 	const zend_class_constant *orig_c = Z_PTR_P(zv);
@@ -1163,9 +1198,11 @@ zend_class_entry *zend_persist_class_entry(zend_class_entry *orig_ce)
 			if (prop->ce == orig_ce) {
 				Z_PTR(p->val) = zend_persist_property_info(prop);
 			} else {
-				prop = zend_shared_alloc_get_xlat_entry(prop);
-				if (prop) {
-					Z_PTR(p->val) = prop;
+				zend_property_info *xlat_prop = zend_shared_alloc_get_xlat_entry(prop);
+				if (xlat_prop) {
+					Z_PTR(p->val) = xlat_prop;
+				} else if (!zend_accel_in_shm(prop)) {
+					Z_PTR(p->val) = zend_persist_substituted_property_info(prop);
 				} else {
 					/* This can happen if preloading is used and we inherit a property from an
 					 * internal class. In that case we should keep pointing to the internal

ext/opcache/zend_persist_calc.c

@@ -565,6 +565,20 @@ static void zend_persist_property_info_calc(zend_property_info *prop)
 	}
 }
 
+static void zend_persist_substituted_property_info_calc(zend_property_info *prop)
+{
+	ADD_SIZE(sizeof(zend_property_info));
+	zend_persist_type_calc(&prop->type);
+	if (prop->hooks) {
+		ADD_SIZE(ZEND_PROPERTY_HOOK_STRUCT_SIZE);
+		for (uint32_t i = 0; i < ZEND_PROPERTY_HOOK_COUNT; i++) {
+			if (prop->hooks[i]) {
+				zend_persist_class_method_calc(&prop->hooks[i]->op_array);
+			}
+		}
+	}
+}
+
 static void zend_persist_class_constant_calc(const zval *zv)
 {
 	zend_class_constant *c = Z_PTR_P(zv);
@@ -648,6 +662,9 @@ void zend_persist_class_entry_calc(zend_class_entry *ce)
 			ADD_INTERNED_STRING(p->key);
 			if (prop->ce == ce) {
 				zend_persist_property_info_calc(prop);
+			} else if (!zend_accel_in_shm(prop) && !zend_shared_alloc_get_xlat_entry(prop)) {
+				zend_shared_alloc_register_xlat_entry(prop, prop);
+				zend_persist_substituted_property_info_calc(prop);
 			}
 		} ZEND_HASH_FOREACH_END();