An attempt to implemnt "preloading" ability.

Zend/zend.c

@@ -566,8 +566,13 @@ static void auto_global_dtor(zval *zv) /* {{{ */
 static void function_copy_ctor(zval *zv) /* {{{ */
 {
 	zend_function *old_func = Z_FUNC_P(zv);
-	zend_function *func = pemalloc(sizeof(zend_internal_function), 1);
+	zend_function *func;
 
+	if (old_func->type == ZEND_USER_FUNCTION) {
+		ZEND_ASSERT(old_func->op_array.fn_flags & ZEND_ACC_IMMUTABLE);
+		return;
+	}
+	func = pemalloc(sizeof(zend_internal_function), 1);
 	Z_FUNC_P(zv) = func;
 	memcpy(func, old_func, sizeof(zend_internal_function));
 	function_add_ref(func);
@@ -977,14 +982,17 @@ int zend_post_startup(void) /* {{{ */
 
 	zend_destroy_rsrc_list(&EG(persistent_list));
 	free(compiler_globals->function_table);
+	compiler_globals->function_table = NULL;
 	free(compiler_globals->class_table);
+	compiler_globals->class_table = NULL;
 	if ((script_encoding_list = (zend_encoding **)compiler_globals->script_encoding_list)) {
 		compiler_globals_ctor(compiler_globals);
 		compiler_globals->script_encoding_list = (const zend_encoding **)script_encoding_list;
 	} else {
 		compiler_globals_ctor(compiler_globals);
 	}
 	free(EG(zend_constants));
+	EG(zend_constants) = NULL;
 
 	executor_globals_ctor(executor_globals);
 	global_persistent_list = &EG(persistent_list);

Zend/zend_compile.h

@@ -260,7 +260,7 @@ typedef struct _zend_oparray_context {
 /* User class has methods with static variables           |     |     |     */
 #define ZEND_HAS_STATIC_IN_METHODS       (1 << 15) /*  X  |     |     |     */
 /*                                                        |     |     |     */
-/* Function Flags (unused: 26...30)                       |     |     |     */
+/* Function Flags (unused: 27...30)                       |     |     |     */
 /* ==============                                         |     |     |     */
 /*                                                        |     |     |     */
 /* deprecation flag                                       |     |     |     */
@@ -310,6 +310,9 @@ typedef struct _zend_oparray_context {
 /* internal function is allocated at arena (int only)     |     |     |     */
 #define ZEND_ACC_ARENA_ALLOCATED         (1 << 25) /*     |  X  |     |     */
 /*                                                        |     |     |     */
+/* op_array is a clone of trait method                    |     |     |     */
+#define ZEND_ACC_TRAIT_CLONE             (1 << 26) /*     |  X  |     |     */
+/*                                                        |     |     |     */
 /* op_array uses strict mode types                        |     |     |     */
 #define ZEND_ACC_STRICT_TYPES            (1 << 31) /*     |  X  |     |     */
 

Zend/zend_execute_API.c

@@ -340,13 +340,56 @@ void shutdown_executor(void) /* {{{ */
 				destroy_op_array(&func->op_array);
 				zend_string_release_ex(key, 0);
 			} ZEND_HASH_FOREACH_END_DEL();
+
+			/* Cleanup preloaded immutable functions */
+			ZEND_HASH_REVERSE_FOREACH_VAL(EG(function_table), zv) {
+				zend_op_array *op_array = Z_PTR_P(zv);
+				if (op_array->type == ZEND_INTERNAL_FUNCTION) {
+					break;
+				}
+				ZEND_ASSERT(op_array->fn_flags & ZEND_ACC_IMMUTABLE);
+				if (op_array->static_variables) {
+					HashTable *ht = ZEND_MAP_PTR_GET(op_array->static_variables_ptr);
+					if (ht) {
+						ZEND_ASSERT(GC_REFCOUNT(ht) == 1);
+						zend_array_destroy(ht);
+					}
+				}
+			} ZEND_HASH_FOREACH_END();
+
 			ZEND_HASH_REVERSE_FOREACH_STR_KEY_VAL(EG(class_table), key, zv) {
 				if (_idx == EG(persistent_classes_count)) {
 					break;
 				}
 				destroy_zend_class(zv);
 				zend_string_release_ex(key, 0);
 			} ZEND_HASH_FOREACH_END_DEL();
+
+			/* Cleanup preloaded immutable classes */
+			ZEND_HASH_REVERSE_FOREACH_VAL(EG(class_table), zv) {
+				zend_class_entry *ce = Z_PTR_P(zv);
+				if (ce->type == ZEND_INTERNAL_CLASS) {
+					break;
+				}
+				ZEND_ASSERT(ce->ce_flags & ZEND_ACC_IMMUTABLE);
+				if (ce->default_static_members_count) {
+					zend_cleanup_internal_class_data(ce);
+				}
+				if (ce->ce_flags & ZEND_HAS_STATIC_IN_METHODS) {
+					zend_op_array *op_array;
+						ZEND_HASH_FOREACH_PTR(&ce->function_table, op_array) {
+						if (op_array->type == ZEND_USER_FUNCTION) {
+							if (op_array->static_variables) {
+								HashTable *ht = ZEND_MAP_PTR_GET(op_array->static_variables_ptr);
+								if (ht) {
+									ZEND_ASSERT(GC_REFCOUNT(ht) == 1);
+									zend_array_destroy(ht);
+								}
+							}
+						}
+					} ZEND_HASH_FOREACH_END();
+				}
+			} ZEND_HASH_FOREACH_END();
 		}
 
 		zend_cleanup_internal_classes();

Zend/zend_inheritance.c

@@ -1308,6 +1308,7 @@ static void zend_add_trait_method(zend_class_entry *ce, const char *name, zend_s
 	} else {
 		new_fn = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
 		memcpy(new_fn, fn, sizeof(zend_op_array));
+		new_fn->op_array.fn_flags |= ZEND_ACC_TRAIT_CLONE;
 		new_fn->op_array.fn_flags &= ~ZEND_ACC_IMMUTABLE;
 	}
 	function_add_ref(new_fn);

Zend/zend_opcode.c

@@ -362,7 +362,9 @@ void zend_class_add_ref(zval *zv)
 {
 	zend_class_entry *ce = Z_PTR_P(zv);
 
-	ce->refcount++;
+	if (!(ce->ce_flags & ZEND_ACC_IMMUTABLE)) {
+		ce->refcount++;
+	}
 }
 
 ZEND_API void destroy_op_array(zend_op_array *op_array)

Zend/zend_signal.c

@@ -322,8 +322,10 @@ void zend_signal_activate(void)
 
 	memcpy(&SIGG(handlers), &global_orig_handlers, sizeof(global_orig_handlers));
 
-	for (x = 0; x < sizeof(zend_sigs) / sizeof(*zend_sigs); x++) {
-		zend_signal_register(zend_sigs[x], zend_signal_handler_defer);
+	if (SIGG(reset)) {
+		for (x = 0; x < sizeof(zend_sigs) / sizeof(*zend_sigs); x++) {
+			zend_signal_register(zend_sigs[x], zend_signal_handler_defer);
+		}
 	}
 
 	SIGG(active) = 1;
@@ -365,6 +367,7 @@ static void zend_signal_globals_ctor(zend_signal_globals_t *zend_signal_globals)
 	size_t x;
 
 	memset(zend_signal_globals, 0, sizeof(*zend_signal_globals));
+	zend_signal_globals->reset = 1;
 
 	for (x = 0; x < sizeof(zend_signal_globals->pstorage) / sizeof(*zend_signal_globals->pstorage); ++x) {
 		zend_signal_queue_t *queue = &zend_signal_globals->pstorage[x];

Zend/zend_signal.h

@@ -59,6 +59,7 @@ typedef struct _zend_signal_globals_t {
 	int running;            /* in signal handler execution */
 	int active;             /* internal signal handling is enabled */
 	zend_bool check;        /* check for replaced handlers on shutdown */
+	zend_bool reset;        /* reset signal handlers on each request */
 	zend_signal_entry_t handlers[NSIG];
 	zend_signal_queue_t pstorage[ZEND_SIGNAL_QUEUE_SIZE], *phead, *ptail, *pavail; /* pending queue */
 } zend_signal_globals_t;

ext/opcache/Optimizer/optimize_func_calls.c

@@ -95,6 +95,8 @@ static void zend_try_inline_call(zend_op_array *op_array, zend_op *fcall, zend_o
 {
 	if (func->type == ZEND_USER_FUNCTION
 	 && !(func->op_array.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_HAS_TYPE_HINTS))
+		/* TODO: function copied from trait may be inconsistent ??? */
+	 && !(func->op_array.fn_flags & (ZEND_ACC_TRAIT_CLONE))
 	 && fcall->extended_value >= func->op_array.required_num_args
 	 && func->op_array.opcodes[func->op_array.num_args].opcode == ZEND_RETURN) {
 

ext/opcache/Optimizer/zend_call_graph.c

@@ -53,6 +53,7 @@ static int zend_op_array_collect(zend_call_graph *call_graph, zend_op_array *op_
 static int zend_foreach_op_array(zend_call_graph *call_graph, zend_script *script, zend_op_array_func_t func)
 {
 	zend_class_entry *ce;
+	zend_string *key;
 	zend_op_array *op_array;
 
 	if (func(call_graph, &script->main_op_array) != SUCCESS) {
@@ -65,9 +66,12 @@ static int zend_foreach_op_array(zend_call_graph *call_graph, zend_script *scrip
 		}
 	} ZEND_HASH_FOREACH_END();
 
-	ZEND_HASH_FOREACH_PTR(&script->class_table, ce) {
+	ZEND_HASH_FOREACH_STR_KEY_PTR(&script->class_table, key, ce) {
+		if (ce->refcount > 1 && !zend_string_equals_ci(key, ce->name)) {
+			continue;
+		}
 		ZEND_HASH_FOREACH_PTR(&ce->function_table, op_array) {
-			if (op_array->scope == ce) {
+			if (op_array->scope == ce && !(op_array->fn_flags & ZEND_ACC_TRAIT_CLONE)) {
 				if (func(call_graph, op_array) != SUCCESS) {
 					return FAILURE;
 				}

ext/opcache/Optimizer/zend_optimizer.c

@@ -1421,6 +1421,7 @@ static void zend_adjust_fcall_stack_size_graph(zend_op_array *op_array)
 int zend_optimize_script(zend_script *script, zend_long optimization_level, zend_long debug_level)
 {
 	zend_class_entry *ce;
+	zend_string *key;
 	zend_op_array *op_array;
 	zend_string *name;
 	zend_optimizer_ctx ctx;
@@ -1440,9 +1441,12 @@ int zend_optimize_script(zend_script *script, zend_long optimization_level, zend
 		zend_optimize_op_array(op_array, &ctx);
 	} ZEND_HASH_FOREACH_END();
 
-	ZEND_HASH_FOREACH_PTR(&script->class_table, ce) {
+	ZEND_HASH_FOREACH_STR_KEY_PTR(&script->class_table, key, ce) {
+		if (ce->refcount > 1 && !zend_string_equals_ci(key, ce->name)) {
+			continue;
+		}
 		ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->function_table, name, op_array) {
-			if (op_array->scope == ce) {
+			if (op_array->scope == ce && !(op_array->fn_flags & ZEND_ACC_TRAIT_CLONE)) {
 				zend_optimize_op_array(op_array, &ctx);
 			}
 		} ZEND_HASH_FOREACH_END();
@@ -1544,27 +1548,35 @@ int zend_optimize_script(zend_script *script, zend_long optimization_level, zend
 			zend_adjust_fcall_stack_size(op_array, &ctx);
 		} ZEND_HASH_FOREACH_END();
 
-		ZEND_HASH_FOREACH_PTR(&script->class_table, ce) {
+		ZEND_HASH_FOREACH_STR_KEY_PTR(&script->class_table, key, ce) {
+			if (ce->refcount > 1 && !zend_string_equals_ci(key, ce->name)) {
+				continue;
+			}
 			ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->function_table, name, op_array) {
-				if (op_array->scope == ce) {
+				if (op_array->scope == ce && !(op_array->fn_flags & ZEND_ACC_TRAIT_CLONE)) {
 					zend_adjust_fcall_stack_size(op_array, &ctx);
 				}
 			} ZEND_HASH_FOREACH_END();
 		} ZEND_HASH_FOREACH_END();
 	}
 
-	ZEND_HASH_FOREACH_PTR(&script->class_table, ce) {
+	ZEND_HASH_FOREACH_STR_KEY_PTR(&script->class_table, key, ce) {
+		if (ce->refcount > 1 && !zend_string_equals_ci(key, ce->name)) {
+			continue;
+		}
 		ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->function_table, name, op_array) {
 			if (op_array->scope != ce && op_array->type == ZEND_USER_FUNCTION) {
 				zend_op_array *orig_op_array =
 					zend_hash_find_ptr(&op_array->scope->function_table, name);
 
 				ZEND_ASSERT(orig_op_array != NULL);
 				if (orig_op_array != op_array) {
+					uint32_t fn_flags = op_array->fn_flags;
 					zend_function *prototype = op_array->prototype;
 					HashTable *ht = op_array->static_variables;
 
 					*op_array = *orig_op_array;
+					op_array->fn_flags = fn_flags;
 					op_array->prototype = prototype;
 					op_array->static_variables = ht;
 				}
@@ -1582,7 +1594,7 @@ int zend_optimize_script(zend_script *script, zend_long optimization_level, zend
 
 		ZEND_HASH_FOREACH_PTR(&script->class_table, ce) {
 			ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->function_table, name, op_array) {
-				if (op_array->scope == ce) {
+				if (op_array->scope == ce && !(op_array->fn_flags & ZEND_ACC_TRAIT_CLONE)) {
 					zend_dump_op_array(op_array, ZEND_DUMP_RT_CONSTANTS, "after optimizer", NULL);
 				}
 			} ZEND_HASH_FOREACH_END();