Fixes

Author: DanielEScherzer

Zend/Optimizer/zend_optimizer.c

@@ -784,6 +784,13 @@ static bool zend_optimizer_ignore_class(zval *ce_zv, zend_string *filename)
 			return false;
 		}
 	}
+	// Ignore deprecated aliases so that they are fetched at runtime
+	if (Z_TYPE_P(ce_zv) == IS_ALIAS_PTR) {
+		zend_class_alias *alias = Z_CLASS_ALIAS_P(ce_zv);
+		if (alias->alias_flags & ZEND_ACC_DEPRECATED) {
+			return true;
+		}
+	}
 	return ce->type == ZEND_USER_CLASS
 		&& (!ce->info.user.filename || ce->info.user.filename != filename);
 }
@@ -817,6 +824,12 @@ zend_class_entry *zend_optimizer_get_class_entry(
 			return Z_PTR_P(ce_or_alias);
 		}
 		ZEND_ASSERT(Z_TYPE_P(ce_or_alias) == IS_ALIAS_PTR);
+		zend_class_alias *alias = Z_CLASS_ALIAS_P(ce_or_alias);
+		if (alias->alias_flags & ZEND_ACC_DEPRECATED) {
+			// Pretend that the class cannot be found so that it gets looked
+			// up at runtime
+			return NULL;
+		}
 		return Z_CLASS_ALIAS_P(ce_or_alias)->ce;
 	}
 

Zend/zend_API.c

@@ -3617,6 +3617,8 @@ ZEND_API zend_result zend_register_class_alias_ex(const char *name, size_t name_
 		}
 		return SUCCESS;
 	}
+
+	zend_string_release(original_name);
 	return FAILURE;
 }
 /* }}} */

Zend/zend_execute_API.c

@@ -328,6 +328,9 @@ ZEND_API void zend_shutdown_executor_values(bool fast_shutdown)
 			}
 		} ZEND_HASH_FOREACH_END();
 		ZEND_HASH_MAP_REVERSE_FOREACH_VAL(EG(class_table), zv) {
+			if (Z_TYPE_P(zv) == IS_ALIAS_PTR) {
+				continue;
+			}
 			zend_class_entry *ce;
 			Z_CE_FROM_ZVAL_P(ce, zv);
 

Zend/zend_opcode.c

@@ -301,11 +301,11 @@ ZEND_API void destroy_zend_class(zval *zv)
 
 		if (class_alias->attributes) {
 			zend_hash_release(class_alias->attributes);
-			class_alias->attributes = NULL;
+			// class_alias->attributes = NULL;
 		}
 		if (class_alias->name) {
 			zend_string_release(class_alias->name);
-			class_alias->name = NULL;
+			// class_alias->name = NULL;
 		}
 		return;
 	}

ext/opcache/ZendAccelerator.c

@@ -4146,6 +4146,14 @@ static void preload_link(void)
 				continue;
 			}
 
+			// Not preloading class constants for deprecated aliases
+			if (Z_TYPE_P(zv) == IS_ALIAS_PTR) {
+				zend_class_alias *class_alias = Z_CLASS_ALIAS_P(zv);
+				if (class_alias->alias_flags & ZEND_ACC_DEPRECATED) {
+					continue;
+				}
+			}
+
 			if ((ce->ce_flags & ZEND_ACC_LINKED) && !(ce->ce_flags & ZEND_ACC_CONSTANTS_UPDATED)) {
 				if (!(ce->ce_flags & ZEND_ACC_TRAIT)) { /* don't update traits */
 					CG(in_compilation) = true; /* prevent autoloading */

ext/opcache/jit/zend_jit.c

@@ -570,7 +570,9 @@ static zend_class_entry* zend_get_known_class(const zend_op_array *op_array, con
 
 		ZEND_ASSERT(Z_TYPE_P(zv) == IS_STRING);
 		class_name = Z_STR_P(zv);
-		ce = zend_lookup_class_ex(class_name, NULL, ZEND_FETCH_CLASS_NO_AUTOLOAD);
+		// ZEND_FETCH_CLASS_SILENT - ignore alias deprecation
+		// TODO but we want to not cache the ce if i is a deprecated alias
+		ce = zend_lookup_class_ex(class_name, NULL, ZEND_FETCH_CLASS_NO_AUTOLOAD | ZEND_FETCH_CLASS_SILENT);
 		if (ce && (ce->type == ZEND_INTERNAL_CLASS || ce->info.user.filename != op_array->filename)) {
 			ce = NULL;
 		}

ext/opcache/zend_accelerator_util_funcs.c

@@ -365,15 +365,19 @@ static void zend_accel_do_delayed_early_binding(
 	CG(in_compilation) = 1;
 	for (uint32_t i = 0; i < persistent_script->num_early_bindings; i++) {
 		zend_early_binding *early_binding = &persistent_script->early_bindings[i];
-		zend_class_entry *ce = zend_hash_find_ex_ptr(EG(class_table), early_binding->lcname, 1);
-		if (!ce) {
+		zval *ce_or_alias = zend_hash_find_ex(EG(class_table), early_binding->lcname, 1);
+		if (!ce_or_alias) {
 			zval *zv = zend_hash_find_known_hash(EG(class_table), early_binding->rtd_key);
+			zend_class_entry *ce = NULL;
 			if (zv) {
-				zend_class_entry *orig_ce = Z_CE_P(zv);
-				zend_class_entry *parent_ce = !(orig_ce->ce_flags & ZEND_ACC_LINKED)
-					? zend_hash_find_ex_ptr(EG(class_table), early_binding->lc_parent_name, 1)
+				zend_class_entry *orig_ce;
+				Z_CE_FROM_ZVAL_P(orig_ce, zv);
+				zval *parent_ce_or_alias = !(orig_ce->ce_flags & ZEND_ACC_LINKED)
+					? zend_hash_find_ex(EG(class_table), early_binding->lc_parent_name, 1)
 					: NULL;
-				if (parent_ce || (orig_ce->ce_flags & ZEND_ACC_LINKED)) {
+				if (parent_ce_or_alias || (orig_ce->ce_flags & ZEND_ACC_LINKED)) {
+					zend_class_entry *parent_ce;
+					Z_CE_FROM_ZVAL_P(parent_ce, parent_ce_or_alias);
 					ce = zend_try_early_bind(orig_ce, parent_ce, early_binding->lcname, zv);
 				}
 			}

ext/opcache/zend_file_cache.c

@@ -765,6 +765,7 @@ static void zend_file_cache_serialize_class(zval                     *zv,
                                             zend_file_cache_metainfo *info,
                                             void                     *buf)
 {
+	ZEND_ASSERT(Z_TYPE_P(zv) == IS_PTR);
 	zend_class_entry *ce;
 
 	SERIALIZE_PTR(Z_PTR_P(zv));
@@ -1619,6 +1620,7 @@ static void zend_file_cache_unserialize_class_constant(zval                    *
                                                        zend_persistent_script  *script,
                                                        void                    *buf)
 {
+	ZEND_ASSERT(Z_TYPE_P(zv) == IS_PTR);
 	if (!IS_UNSERIALIZED(Z_PTR_P(zv))) {
 		zend_class_constant *c;
 

ext/opcache/zend_persist.c

@@ -29,6 +29,7 @@
 #include "zend_operators.h"
 #include "zend_interfaces.h"
 #include "zend_attributes.h"
+#include "zend_class_alias.h"
 
 #ifdef HAVE_JIT
 # include "Optimizer/zend_func_info.h"
@@ -909,6 +910,21 @@ static void zend_persist_class_constant(zval *zv)
 	zend_persist_type(&c->type);
 }
 
+zend_class_alias *zend_persist_class_alias_entry(zend_class_alias *orig_alias)
+{
+	Bucket *p;
+	zend_class_alias *alias = orig_alias;
+	
+	alias = zend_shared_memdup_put(alias, sizeof(zend_class_alias));
+	alias->ce = zend_persist_class_entry(alias->ce);
+	// zend_accel_store_string(alias->name);
+	if (alias->attributes) {
+		alias->attributes = zend_persist_attributes(alias->attributes);
+	}
+
+	return alias;
+}
+
 zend_class_entry *zend_persist_class_entry(zend_class_entry *orig_ce)
 {
 	Bucket *p;
@@ -1296,7 +1312,12 @@ static void zend_accel_persist_class_table(HashTable *class_table)
 	ZEND_HASH_MAP_FOREACH_BUCKET(class_table, p) {
 		ZEND_ASSERT(p->key != NULL);
 		zend_accel_store_interned_string(p->key);
-		Z_CE(p->val) = zend_persist_class_entry(Z_CE(p->val));
+		if (Z_TYPE(p->val) == IS_ALIAS_PTR) {
+			Z_CLASS_ALIAS(p->val) = zend_persist_class_alias_entry(Z_CLASS_ALIAS(p->val));
+		} else {
+			ZEND_ASSERT(Z_TYPE(p->val) == IS_PTR);
+			Z_CE(p->val) = zend_persist_class_entry(Z_CE(p->val));
+		}
 	} ZEND_HASH_FOREACH_END();
 	ZEND_HASH_MAP_FOREACH_BUCKET(class_table, p) {
 		if (EXPECTED(Z_TYPE(p->val) != IS_ALIAS_PTR)) {

ext/opcache/zend_persist_calc.c

@@ -599,6 +599,11 @@ static void zend_persist_class_alias_entry_calc(zend_class_alias *alias)
 	// alias->ce is going to be a pointer to a class entry that will be
 	// persisted on its own, here we just need to add size for the alias
 	ADD_SIZE(sizeof(zend_class_alias));
+	// And the things that the alias holds directly
+	ADD_INTERNED_STRING(alias->name);
+	if (alias->attributes) {
+		zend_persist_attributes_calc(alias->attributes);
+	}
 	zend_persist_class_entry_calc(alias->ce);
 }