Added Inheritance Cache.

This is a new transparent technology that eliminates overhead of PHP class inheritance.

PHP  classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request.

Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking).

The patch shows 8% improvement on Symphony "Hello World" app.

1 files changed, 348 insertions, 126 deletions

diff --git a/ext/opcache/ZendAccelerator.c b/ext/opcache/ZendAccelerator.c
index 088bca6ebf..9819e7acdd 100644
--- a/ext/opcache/ZendAccelerator.c
+++ b/ext/opcache/ZendAccelerator.c
@@ -118,6 +118,8 @@ bool fallback_process = 0; /* process uses file cache fallback */
 #endif
 
 static zend_op_array *(*accelerator_orig_compile_file)(zend_file_handle *file_handle, int type);
+static zend_class_entry* (*accelerator_orig_inheritance_cache_get)(zend_class_entry *ce, zend_class_entry *parent, zend_class_entry **traits_and_interfaces);
+static zend_class_entry* (*accelerator_orig_inheritance_cache_add)(zend_class_entry *ce, zend_class_entry *proto, zend_class_entry *parent, zend_class_entry **traits_and_interfaces, HashTable *dependencies);
 static zend_result (*accelerator_orig_zend_stream_open_function)(const char *filename, zend_file_handle *handle );
 static zend_string *(*accelerator_orig_zend_resolve_path)(const char *filename, size_t filename_len);
 static void (*accelerator_orig_zend_error_cb)(int type, const char *error_filename, const uint32_t error_lineno, zend_string *message);
@@ -2249,6 +2251,269 @@ zend_op_array *persistent_compile_file(zend_file_handle *file_handle, int type)
 	return zend_accel_load_script(persistent_script, from_shared_memory);
 }
 
+static zend_inheritance_cache_entry* zend_accel_inheritance_cache_find(zend_inheritance_cache_entry *entry, zend_class_entry *ce, zend_class_entry *parent, zend_class_entry **traits_and_interfaces, bool *needs_autoload_ptr)
+{
+	uint32_t i;
+
+	ZEND_ASSERT(ce->ce_flags & ZEND_ACC_IMMUTABLE);
+	ZEND_ASSERT(!(ce->ce_flags & ZEND_ACC_LINKED));
+
+	while (entry) {
+		bool found = 1;
+		bool needs_autoload = 0;
+
+		if (entry->parent != parent) {
+			found = 0;
+		} else {
+			for (i = 0; i < ce->num_traits + ce->num_interfaces; i++) {
+				if (entry->traits_and_interfaces[i] != traits_and_interfaces[i]) {
+					found = 0;
+					break;
+				}
+			}
+			if (found && entry->dependencies) {
+				for (i = 0; i < entry->dependencies_count; i++) {
+					zend_class_entry *ce = zend_lookup_class_ex(entry->dependencies[i].name, NULL, ZEND_FETCH_CLASS_NO_AUTOLOAD);
+
+					if (ce != entry->dependencies[i].ce) {
+						if (!ce) {
+							needs_autoload = 1;
+						} else {
+							found = 0;
+							break;
+						}
+					}
+				}
+			}
+		}
+		if (found) {
+			*needs_autoload_ptr = needs_autoload;
+			return entry;
+		}
+		entry = entry->next;
+	}
+
+	return NULL;
+}
+
+static zend_class_entry* zend_accel_inheritance_cache_get(zend_class_entry *ce, zend_class_entry *parent, zend_class_entry **traits_and_interfaces)
+{
+	uint32_t i;
+	bool needs_autoload;
+	zend_inheritance_cache_entry *entry = ce->inheritance_cache;
+
+	while (entry) {
+		entry = zend_accel_inheritance_cache_find(entry, ce, parent, traits_and_interfaces, &needs_autoload);
+		if (entry) {
+			if (!needs_autoload) {
+				zend_map_ptr_extend(ZCSG(map_ptr_last));
+				return entry->ce;
+			}
+
+			for (i = 0; i < entry->dependencies_count; i++) {
+				zend_class_entry *ce = zend_lookup_class_ex(entry->dependencies[i].name, NULL, 0);
+
+				if (ce == NULL) {
+					return NULL;
+				}
+			}
+		}
+	}
+
+	return NULL;
+}
+
+static bool is_array_cacheable(zval *zv)
+{
+	zval *p;
+
+	ZEND_HASH_FOREACH_VAL(Z_ARR_P(zv), p) {
+		if (Z_REFCOUNTED_P(p)) {
+			if (Z_TYPE_P(p) == IS_ARRAY) {
+				if (!is_array_cacheable(p)) {
+					/* Can't cache */
+					return 0;
+				}
+			} else if (Z_TYPE_P(p) == IS_OBJECT || Z_TYPE_P(p) == IS_RESOURCE || Z_TYPE_P(p) == IS_REFERENCE) {
+				/* Can't cache */
+				return 0;
+			}
+		}
+	} ZEND_HASH_FOREACH_END();
+
+	return 1;
+}
+
+static zend_class_entry* zend_accel_inheritance_cache_add(zend_class_entry *ce, zend_class_entry *proto, zend_class_entry *parent, zend_class_entry **traits_and_interfaces, HashTable *dependencies)
+{
+	zend_persistent_script dummy;
+	size_t size;
+	uint32_t i;
+	bool needs_autoload;
+	zend_class_entry *new_ce;
+	zend_inheritance_cache_entry *entry;
+
+	ZEND_ASSERT(!(ce->ce_flags & ZEND_ACC_IMMUTABLE));
+	ZEND_ASSERT(ce->ce_flags & ZEND_ACC_LINKED);
+
+	if (!ZCG(accelerator_enabled) ||
+        (ZCSG(restart_in_progress) && accel_restart_is_active())) {
+		return NULL;
+	}
+
+	if (traits_and_interfaces && dependencies) {
+		for (i = 0; i < proto->num_traits + proto->num_interfaces; i++) {
+			if (traits_and_interfaces[i]) {
+				zend_hash_del(dependencies, traits_and_interfaces[i]->name);
+			}
+		}
+	}
+
+	if (ce->ce_flags & ZEND_HAS_STATIC_IN_METHODS) {
+		zend_op_array *op_array;
+		zval *zv;
+
+		ZEND_HASH_FOREACH_PTR(&ce->function_table, op_array) {
+			if (op_array->type == ZEND_USER_FUNCTION
+			 && op_array->static_variables
+			 && !(GC_FLAGS(op_array->static_variables) & IS_ARRAY_IMMUTABLE)) {
+				if (UNEXPECTED(GC_REFCOUNT(op_array->static_variables) > 1)) {
+					GC_DELREF(op_array->static_variables);
+					op_array->static_variables = zend_array_dup(op_array->static_variables);
+				}
+				ZEND_HASH_FOREACH_VAL(op_array->static_variables, zv) {
+					if (Z_ISREF_P(zv)) {
+						zend_reference *ref = Z_REF_P(zv);
+
+						ZVAL_COPY_VALUE(zv, &ref->val);
+						if (GC_DELREF(ref) == 0) {
+							efree_size(ref, sizeof(zend_reference));
+						}
+					}
+					if (Z_REFCOUNTED_P(zv)) {
+						if (Z_TYPE_P(zv) == IS_ARRAY) {
+							if (!is_array_cacheable(zv)) {
+								/* Can't cache */
+								return NULL;
+							}
+							SEPARATE_ARRAY(zv);
+						} else if (Z_TYPE_P(zv) == IS_OBJECT || Z_TYPE_P(zv) == IS_RESOURCE) {
+							/* Can't cache */
+							return NULL;
+						}
+					}
+				} ZEND_HASH_FOREACH_END();
+			}
+		} ZEND_HASH_FOREACH_END();
+	}
+
+	SHM_UNPROTECT();
+	zend_shared_alloc_lock();
+
+	entry = ce->inheritance_cache;
+	while (entry) {
+		entry = zend_accel_inheritance_cache_find(entry, ce, parent, traits_and_interfaces, &needs_autoload);
+		if (entry) {
+			if (!needs_autoload) {
+				zend_shared_alloc_unlock();
+				SHM_PROTECT();
+
+				zend_map_ptr_extend(ZCSG(map_ptr_last));
+				return entry->ce;
+			}
+			ZEND_ASSERT(0); // entry = entry->next; // This shouldn't be posible ???
+		}
+	}
+
+	zend_shared_alloc_init_xlat_table();
+
+	memset(&dummy, 0, sizeof(dummy));
+	dummy.size = ZEND_ALIGNED_SIZE(
+		sizeof(zend_inheritance_cache_entry) -
+		sizeof(void*) +
+		(sizeof(void*) * (proto->num_traits + proto->num_interfaces)));
+	if (dependencies) {
+		dummy.size += ZEND_ALIGNED_SIZE(zend_hash_num_elements(dependencies) * sizeof(zend_class_dependency));
+	}
+	ZCG(current_persistent_script) = &dummy;
+	zend_persist_class_entry_calc(ce);
+	size = dummy.size;
+
+	zend_shared_alloc_clear_xlat_table();
+
+#if ZEND_MM_ALIGNMENT < 8
+	/* Align to 8-byte boundary */
+	ZCG(mem) = zend_shared_alloc(size + 8);
+#else
+	ZCG(mem) = zend_shared_alloc(size);
+#endif
+
+	if (!ZCG(mem)) {
+		zend_shared_alloc_destroy_xlat_table();
+		zend_shared_alloc_unlock();
+		SHM_PROTECT();
+		return NULL;
+	}
+
+#if ZEND_MM_ALIGNMENT < 8
+	/* Align to 8-byte boundary */
+	ZCG(mem) = (void*)(((zend_uintptr_t)ZCG(mem) + 7L) & ~7L);
+#endif
+
+	memset(ZCG(mem), 0, size);
+	entry = (zend_inheritance_cache_entry*)ZCG(mem);
+	ZCG(mem) = (char*)ZCG(mem) +
+		ZEND_ALIGNED_SIZE(
+			(sizeof(zend_inheritance_cache_entry) -
+			 sizeof(void*) +
+			 (sizeof(void*) * (proto->num_traits + proto->num_interfaces))));
+	entry->parent = parent;
+	for (i = 0; i < proto->num_traits + proto->num_interfaces; i++) {
+		entry->traits_and_interfaces[i] = traits_and_interfaces[i];
+	}
+	if (dependencies && zend_hash_num_elements(dependencies)) {
+		zend_string *dep_name;
+		zend_class_entry *dep_ce;
+
+		i = 0;
+		entry->dependencies_count = zend_hash_num_elements(dependencies);
+		entry->dependencies = (zend_class_dependency*)ZCG(mem);
+		ZEND_HASH_FOREACH_STR_KEY_PTR(dependencies, dep_name, dep_ce) {
+#if ZEND_DEBUG
+			ZEND_ASSERT(zend_accel_in_shm(dep_name));
+#endif
+			entry->dependencies[i].name = dep_name;
+			entry->dependencies[i].ce = dep_ce;
+			i++;
+		} ZEND_HASH_FOREACH_END();
+		ZCG(mem) = (char*)ZCG(mem) + zend_hash_num_elements(dependencies) * sizeof(zend_class_dependency);
+	}
+	entry->ce = new_ce = zend_persist_class_entry(ce);
+	zend_update_parent_ce(new_ce);
+	entry->next = proto->inheritance_cache;
+	proto->inheritance_cache = entry;
+
+	zend_shared_alloc_destroy_xlat_table();
+
+	zend_shared_alloc_unlock();
+	SHM_PROTECT();
+
+	/* Consistency check */
+	if ((char*)entry + size != (char*)ZCG(mem)) {
+		zend_accel_error(
+			((char*)entry + size < (char*)ZCG(mem)) ? ACCEL_LOG_ERROR : ACCEL_LOG_WARNING,
+			"Internal error: wrong class size calculation: %s start=" ZEND_ADDR_FMT ", end=" ZEND_ADDR_FMT ", real=" ZEND_ADDR_FMT "\n",
+			ZSTR_VAL(ce->name),
+			(size_t)entry,
+			(size_t)((char *)entry + size),
+			(size_t)ZCG(mem));
+	}
+
+	zend_map_ptr_extend(ZCSG(map_ptr_last));
+
+	return new_ce;
+}
+
 #ifdef ZEND_WIN32
 static int accel_gen_uname_id(void)
 {
@@ -3123,7 +3388,19 @@ file_cache_fallback:
 		accel_use_shm_interned_strings();
 	}
 
-	return accel_finish_startup();
+	if (accel_finish_startup() != SUCCESS) {
+		return FAILURE;
+	}
+
+	if (ZCG(enabled) && accel_startup_ok) {
+		/* Override inheritance cache callbaks */
+		accelerator_orig_inheritance_cache_get = zend_inheritance_cache_get;
+		accelerator_orig_inheritance_cache_add = zend_inheritance_cache_add;
+		zend_inheritance_cache_get = zend_accel_inheritance_cache_get;
+		zend_inheritance_cache_add = zend_accel_inheritance_cache_add;
+	}
+
+	return SUCCESS;
 }
 
 static void (*orig_post_shutdown_cb)(void);
@@ -3170,6 +3447,8 @@ void accel_shutdown(void)
 	}
 
 	zend_compile_file = accelerator_orig_compile_file;
+	zend_inheritance_cache_get = accelerator_orig_inheritance_cache_get;
+	zend_inheritance_cache_add = accelerator_orig_inheritance_cache_add;
 
 	if ((ini_entry = zend_hash_str_find_ptr(EG(ini_directives), "include_path", sizeof("include_path")-1)) != NULL) {
 		ini_entry->on_modify = orig_include_path_on_modify;
@@ -3472,34 +3751,6 @@ try_again:
 	}
 }
 
-static void get_unresolved_initializer(zend_class_entry *ce, const char **kind, const char **name) {
-	zend_string *key;
-	zend_class_constant *c;
-	zend_property_info *prop;
-
-	*kind = "unknown";
-	*name = "";
-
-	ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->constants_table, key, c) {
-		if (Z_TYPE(c->value) == IS_CONSTANT_AST) {
-			*kind = "constant ";
-			*name = ZSTR_VAL(key);
-		}
-	} ZEND_HASH_FOREACH_END();
-	ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->properties_info, key, prop) {
-		zval *val;
-		if (prop->flags & ZEND_ACC_STATIC) {
-			val = &ce->default_static_members_table[prop->offset];
-		} else {
-			val = &ce->default_properties_table[OBJ_PROP_TO_NUM(prop->offset)];
-		}
-		if (Z_TYPE_P(val) == IS_CONSTANT_AST) {
-			*kind = (prop->flags & ZEND_ACC_STATIC) ? "static property $" : "property $";
-			*name = ZSTR_VAL(key);
-		}
-	} ZEND_HASH_FOREACH_END();
-}
-
 static bool preload_needed_types_known(zend_class_entry *ce);
 static void get_unlinked_dependency(zend_class_entry *ce, const char **kind, const char **name) {
 	zend_class_entry *p;
@@ -3515,16 +3766,6 @@ static void get_unlinked_dependency(zend_class_entry *ce, const char **kind, con
 			*name = ZSTR_VAL(ce->parent_name);
 			return;
 		}
-		if (!(p->ce_flags & ZEND_ACC_CONSTANTS_UPDATED)) {
-			*kind = "Parent with unresolved initializers ";
-			*name = ZSTR_VAL(ce->parent_name);
-			return;
-		}
-		if (!(p->ce_flags & ZEND_ACC_PROPERTY_TYPES_RESOLVED)) {
-			*kind = "Parent with unresolved property types ";
-			*name = ZSTR_VAL(ce->parent_name);
-			return;
-		}
 	}
 
 	if (ce->num_interfaces) {
@@ -3559,12 +3800,11 @@ static void get_unlinked_dependency(zend_class_entry *ce, const char **kind, con
 
 static bool preload_try_resolve_constants(zend_class_entry *ce)
 {
-	bool ok, changed;
+	bool ok, changed, was_changed = 0;
 	zend_class_constant *c;
 	zval *val;
 
 	EG(exception) = (void*)(uintptr_t)-1; /* prevent error reporting */
-	CG(in_compilation) = 1; /* prevent autoloading */
 	do {
 		ok = 1;
 		changed = 0;
@@ -3572,62 +3812,65 @@ static bool preload_try_resolve_constants(zend_class_entry *ce)
 			val = &c->value;
 			if (Z_TYPE_P(val) == IS_CONSTANT_AST) {
 				if (EXPECTED(zval_update_constant_ex(val, c->ce) == SUCCESS)) {
-					changed = 1;
+					was_changed = changed = 1;
 				} else {
 					ok = 0;
 				}
 			}
 		} ZEND_HASH_FOREACH_END();
+		if (ok) {
+			ce->ce_flags &= ~ZEND_ACC_HAS_AST_CONSTANTS;
+		}
 		if (ce->default_properties_count) {
 			uint32_t i;
+			bool resolved = 1;
+
 			for (i = 0; i < ce->default_properties_count; i++) {
 				val = &ce->default_properties_table[i];
 				if (Z_TYPE_P(val) == IS_CONSTANT_AST) {
 					zend_property_info *prop = ce->properties_info_table[i];
 					if (UNEXPECTED(zval_update_constant_ex(val, prop->ce) != SUCCESS)) {
-						ok = 0;
+						resolved = ok = 0;
 					}
 				}
 			}
+			if (resolved) {
+				ce->ce_flags &= ~ZEND_ACC_HAS_AST_PROPERTIES;
+			}
 		}
 		if (ce->default_static_members_count) {
 			uint32_t count = ce->parent ? ce->default_static_members_count - ce->parent->default_static_members_count : ce->default_static_members_count;
+			bool resolved = 1;
 
 			val = ce->default_static_members_table + ce->default_static_members_count - 1;
 			while (count) {
 				if (Z_TYPE_P(val) == IS_CONSTANT_AST) {
 					if (UNEXPECTED(zval_update_constant_ex(val, ce) != SUCCESS)) {
-						ok = 0;
+						resolved = ok = 0;
 					}
 				}
 				val--;
 				count--;
 			}
+			if (resolved) {
+				ce->ce_flags &= ~ZEND_ACC_HAS_AST_STATICS;
+			}
 		}
 	} while (changed && !ok);
 	EG(exception) = NULL;
 	CG(in_compilation) = 0;
 
-	return ok;
+	if (ok) {
+		ce->ce_flags |= ZEND_ACC_CONSTANTS_UPDATED;
+	}
+
+	return ok || was_changed;
 }
 
-static zend_class_entry *preload_fetch_resolved_ce(zend_string *name, zend_class_entry *self_ce) {
+static zend_class_entry *preload_fetch_resolved_ce(zend_string *name) {
 	zend_string *lcname = zend_string_tolower(name);
 	zend_class_entry *ce = zend_hash_find_ptr(EG(class_table), lcname);
 	zend_string_release(lcname);
-	if (!ce) {
-		return NULL;
-	}
-	if (ce == self_ce) {
-		/* Ignore the following requirements if this is the class referring to itself */
-		return ce;
-	}
-	if (!(ce->ce_flags & ZEND_ACC_CONSTANTS_UPDATED)) {
-		return NULL;
-	}
-	if (!(ce->ce_flags & ZEND_ACC_PROPERTY_TYPES_RESOLVED)) {
-		return NULL;
-	}
 	return ce;
 }
 
@@ -3641,7 +3884,7 @@ static bool preload_try_resolve_property_types(zend_class_entry *ce)
 			ZEND_TYPE_FOREACH(prop->type, single_type) {
 				if (ZEND_TYPE_HAS_NAME(*single_type)) {
 					zend_class_entry *p =
-						preload_fetch_resolved_ce(ZEND_TYPE_NAME(*single_type), ce);
+						preload_fetch_resolved_ce(ZEND_TYPE_NAME(*single_type));
 					if (!p) {
 						ok = 0;
 						continue;
@@ -3650,6 +3893,9 @@ static bool preload_try_resolve_property_types(zend_class_entry *ce)
 				}
 			} ZEND_TYPE_FOREACH_END();
 		} ZEND_HASH_FOREACH_END();
+		if (ok) {
+			ce->ce_flags |= ZEND_ACC_PROPERTY_TYPES_RESOLVED;
+		}
 	}
 
 	return ok;
@@ -3778,12 +4024,6 @@ static void preload_link(void)
 					parent = zend_hash_find_ptr(EG(class_table), key);
 					zend_string_release(key);
 					if (!parent) continue;
-					if (!(parent->ce_flags & ZEND_ACC_CONSTANTS_UPDATED)) {
-						continue;
-					}
-					if (!(parent->ce_flags & ZEND_ACC_PROPERTY_TYPES_RESOLVED)) {
-						continue;
-					}
 				}
 
 				if (ce->num_interfaces) {
@@ -3794,10 +4034,6 @@ static void preload_link(void)
 							found = 0;
 							break;
 						}
-						if (!(p->ce_flags & ZEND_ACC_CONSTANTS_UPDATED)) {
-							found = 0;
-							break;
-						}
 					}
 					if (!found) continue;
 				}
@@ -3822,11 +4058,8 @@ static void preload_link(void)
 					continue;
 				}
 
-				{
-					zend_string *key = zend_string_tolower(ce->name);
-					zv = zend_hash_set_bucket_key(EG(class_table), (Bucket*)zv, key);
-					zend_string_release(key);
-				}
+				key = zend_string_tolower(ce->name);
+				zv = zend_hash_set_bucket_key(EG(class_table), (Bucket*)zv, key);
 
 				if (EXPECTED(zv)) {
 					/* Set filename & lineno information for inheritance errors */
@@ -3842,7 +4075,8 @@ static void preload_link(void)
 					} else {
 						CG(zend_lineno) = ce->info.user.line_start;
 					}
-					if (zend_do_link_class(ce, NULL) == FAILURE) {
+					ce = zend_do_link_class(ce, NULL, key);
+					if (!ce) {
 						ZEND_ASSERT(0 && "Class linking failed?");
 					}
 					CG(in_compilation) = 0;
@@ -3850,22 +4084,41 @@ static void preload_link(void)
 
 					changed = 1;
 				}
+
+				zend_string_release(key);
 			}
-			if (ce->ce_flags & ZEND_ACC_LINKED) {
-				if (!(ce->ce_flags & ZEND_ACC_CONSTANTS_UPDATED)) {
-					if ((ce->ce_flags & ZEND_ACC_TRAIT) /* don't update traits */
-					 || preload_try_resolve_constants(ce)) {
-						ce->ce_flags |= ZEND_ACC_CONSTANTS_UPDATED;
-						changed = 1;
-					}
-				}
+		} ZEND_HASH_FOREACH_END();
+	} while (changed);
+
+	/* Resolve property types */
+	ZEND_HASH_REVERSE_FOREACH_VAL(EG(class_table), zv) {
+		ce = Z_PTR_P(zv);
+		if (ce->type == ZEND_INTERNAL_CLASS) {
+			break;
+		}
+		if (!(ce->ce_flags & ZEND_ACC_PROPERTY_TYPES_RESOLVED)) {
+			if (!(ce->ce_flags & ZEND_ACC_TRAIT)) {
+				preload_try_resolve_property_types(ce);
+			}
+		}
+	} ZEND_HASH_FOREACH_END();
+
 
-				if (!(ce->ce_flags & ZEND_ACC_PROPERTY_TYPES_RESOLVED)) {
-					if ((ce->ce_flags & ZEND_ACC_TRAIT) /* don't update traits */
-					 || preload_try_resolve_property_types(ce)) {
-						ce->ce_flags |= ZEND_ACC_PROPERTY_TYPES_RESOLVED;
+	do {
+		changed = 0;
+
+		ZEND_HASH_REVERSE_FOREACH_VAL(EG(class_table), zv) {
+			ce = Z_PTR_P(zv);
+			if (ce->type == ZEND_INTERNAL_CLASS) {
+				break;
+			}
+			if (!(ce->ce_flags & ZEND_ACC_CONSTANTS_UPDATED)) {
+				if (!(ce->ce_flags & ZEND_ACC_TRAIT)) { /* don't update traits */
+					CG(in_compilation) = 1; /* prevent autoloading */
+					if (preload_try_resolve_constants(ce)) {
 						changed = 1;
 					}
+					CG(in_compilation) = 0;
 				}
 			}
 		} ZEND_HASH_FOREACH_END();
@@ -3895,18 +4148,6 @@ static void preload_link(void)
 					ZSTR_VAL(ce->name), kind, name);
 			}
 			zend_string_release(key);
-		} else if (!(ce->ce_flags & ZEND_ACC_CONSTANTS_UPDATED)) {
-			const char *kind, *name;
-			get_unresolved_initializer(ce, &kind, &name);
-			zend_error_at(
-				E_WARNING, ZSTR_VAL(ce->info.user.filename), ce->info.user.line_start,
-				"Can't preload class %s with unresolved initializer for %s%s",
-				ZSTR_VAL(ce->name), kind, name);
-		} else if (!(ce->ce_flags & ZEND_ACC_PROPERTY_TYPES_RESOLVED)) {
-			zend_error_at(
-				E_WARNING, ZSTR_VAL(ce->info.user.filename), ce->info.user.line_start,
-				"Can't preload class %s with unresolved property types",
-				ZSTR_VAL(ce->name));
 		} else {
 			continue;
 		}
@@ -3960,7 +4201,7 @@ static inline int preload_update_class_constants(zend_class_entry *ce) {
 	 * maybe-uninitialized analysis. */
 	int result;
 	zend_try {
-		result = zend_update_class_constants(ce);
+		result = preload_try_resolve_constants(ce) ? SUCCESS : FAILURE;
 	} zend_catch {
 		result = FAILURE;
 	} zend_end_try();
@@ -3976,13 +4217,6 @@ static zend_class_entry *preload_load_prop_type(zend_property_info *prop, zend_s
 	} else {
 		ce = zend_lookup_class(name);
 	}
-	if (ce) {
-		return ce;
-	}
-
-	zend_error_noreturn(E_ERROR,
-		"Failed to load class %s used by typed property %s::$%s during preloading",
-		ZSTR_VAL(name), ZSTR_VAL(prop->ce->name), zend_get_unmangled_property_name(prop->name));
 	return ce;
 }
 
@@ -4008,12 +4242,7 @@ static void preload_ensure_classes_loadable() {
 			}
 
 			if (!(ce->ce_flags & ZEND_ACC_CONSTANTS_UPDATED)) {
-				if (preload_update_class_constants(ce) == FAILURE) {
-					zend_error_noreturn(E_ERROR,
-						"Failed to resolve initializers of class %s during preloading",
-						ZSTR_VAL(ce->name));
-				}
-				ZEND_ASSERT(ce->ce_flags & ZEND_ACC_CONSTANTS_UPDATED);
+				preload_update_class_constants(ce);
 			}
 
 			if (!(ce->ce_flags & ZEND_ACC_PROPERTY_TYPES_RESOLVED)) {
@@ -4025,7 +4254,9 @@ static void preload_ensure_classes_loadable() {
 							if (ZEND_TYPE_HAS_NAME(*single_type)) {
 								zend_class_entry *ce = preload_load_prop_type(
 									prop, ZEND_TYPE_NAME(*single_type));
-								ZEND_TYPE_SET_CE(*single_type, ce);
+								if (ce) {
+									ZEND_TYPE_SET_CE(*single_type, ce);
+								}
 							}
 						} ZEND_TYPE_FOREACH_END();
 					} ZEND_HASH_FOREACH_END();
@@ -4558,15 +4789,8 @@ static int accel_preload(const char *config, bool in_child)
 			ZEND_ASSERT(ce->ce_flags & ZEND_ACC_PRELOADED);
 			if (ce->default_static_members_count) {
 				zend_cleanup_internal_class_data(ce);
-				if (ce->ce_flags & ZEND_ACC_CONSTANTS_UPDATED) {
-					int i;
-
-					for (i = 0; i < ce->default_static_members_count; i++) {
-						if (Z_TYPE(ce->default_static_members_table[i]) == IS_CONSTANT_AST) {
-							ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
-							break;
-						}
-					}
+				if (ce->ce_flags & ZEND_ACC_HAS_AST_STATICS) {
+					ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
 				}
 			}
 			if (ce->ce_flags & ZEND_HAS_STATIC_IN_METHODS) {
@@ -4701,8 +4925,6 @@ static int accel_preload(const char *config, bool in_child)
 		SHM_PROTECT();
 		HANDLE_UNBLOCK_INTERRUPTIONS();
 
-		ZEND_ASSERT(ZCSG(preload_script)->arena_size == 0);
-
 		preload_load();
 
 		/* Store individual scripts with unlinked classes */