Always use CE_CACHE, remove TYPE_HAS_CE (#7336)

Currently, CE_CACHE on strings is only used with opcache interned strings. This
patch extends usage to non-opcache interned strings as well. This means that
most type strings can now make use of CE_CACHE even if opcache is not loaded,
which allows us to remove TYPE_HAS_CE kind, and fix some discrepancies
depending on whether a type stores a resolved or non-resolved name.

There are two cases where CE_CACHE will not be used:

 * When opcache is not used and a permanent interned string (that is not an
   internal class name) is used as a type name during the request. In this case
   we can't allocate a map_ptr index for the permanent string, as it would be
   not be in the permanent map_ptr index space.
 * When opcache is used but the script is not cached (e.g. eval'd code or
   opcache full). If opcache is used, we can't allocate additional map_ptr
   indexes at runtime, because they may conflict with indexes allocated by
   opcache.

In these two cases we would end up not using CE caching for property types
(argument/return types still have the separate cache slot).

Author: nikic

Zend/Optimizer/zend_inference.c

@@ -2269,9 +2269,7 @@ static uint32_t zend_convert_type(const zend_script *script, zend_type type, zen
 		if (pce) {
 			/* As we only have space to store one CE,
 			 * we use a plain object type for class unions. */
-			if (ZEND_TYPE_HAS_CE(type)) {
-				*pce = ZEND_TYPE_CE(type);
-			} else if (ZEND_TYPE_HAS_NAME(type)) {
+			if (ZEND_TYPE_HAS_NAME(type)) {
 				zend_string *lcname = zend_string_tolower(ZEND_TYPE_NAME(type));
 				*pce = zend_optimizer_get_class_entry(script, lcname);
 				zend_string_release_ex(lcname, 0);

Zend/tests/objects_008.phpt

@@ -1,9 +1,5 @@
 --TEST--
 method overloading with different method signature
---SKIPIF--
-<?php
-if (getenv('SKIP_PRELOAD')) die('xfail Difference in class name casing');
-?>
 --FILE--
 <?php
 

Zend/zend.c

@@ -38,6 +38,7 @@
 #include "Optimizer/zend_optimizer.h"
 
 static size_t global_map_ptr_last = 0;
+static bool startup_done = false;
 
 #ifdef ZTS
 ZEND_API int compiler_globals_id;
@@ -1018,40 +1019,6 @@ void zend_register_standard_ini_entries(void) /* {{{ */
 }
 /* }}} */
 
-static zend_class_entry *resolve_type_name(zend_string *type_name) {
-	zend_string *lc_type_name = zend_string_tolower(type_name);
-	zend_class_entry *ce = zend_hash_find_ptr(CG(class_table), lc_type_name);
-
-	ZEND_ASSERT(ce && ce->type == ZEND_INTERNAL_CLASS);
-	zend_string_release(lc_type_name);
-	return ce;
-}
-
-static void zend_resolve_property_types(void) /* {{{ */
-{
-	zend_class_entry *ce;
-	zend_property_info *prop_info;
-
-	ZEND_HASH_FOREACH_PTR(CG(class_table), ce) {
-		if (ce->type != ZEND_INTERNAL_CLASS) {
-			continue;
-		}
-
-		if (UNEXPECTED(ZEND_CLASS_HAS_TYPE_HINTS(ce))) {
-			ZEND_HASH_FOREACH_PTR(&ce->properties_info, prop_info) {
-				zend_type *single_type;
-				ZEND_TYPE_FOREACH(prop_info->type, single_type) {
-					if (ZEND_TYPE_HAS_NAME(*single_type)) {
-						zend_string *type_name = ZEND_TYPE_NAME(*single_type);
-						ZEND_TYPE_SET_CE(*single_type, resolve_type_name(type_name));
-						zend_string_release(type_name);
-					}
-				} ZEND_TYPE_FOREACH_END();
-			} ZEND_HASH_FOREACH_END();
-		}
-	} ZEND_HASH_FOREACH_END();
-}
-/* }}} */
 
 /* Unlink the global (r/o) copies of the class, function and constant tables,
  * and use a fresh r/w copy for the startup thread
@@ -1065,7 +1032,7 @@ zend_result zend_post_startup(void) /* {{{ */
 	zend_executor_globals *executor_globals = ts_resource(executor_globals_id);
 #endif
 
-	zend_resolve_property_types();
+	startup_done = true;
 
 	if (zend_post_startup_cb) {
 		zend_result (*cb)(void) = zend_post_startup_cb;
@@ -1164,6 +1131,7 @@ void zend_shutdown(void) /* {{{ */
 	zend_destroy_rsrc_list_dtors();
 
 	zend_optimizer_shutdown();
+	startup_done = false;
 }
 /* }}} */
 
@@ -1892,3 +1860,29 @@ ZEND_API void zend_map_ptr_extend(size_t last)
 		CG(map_ptr_last) = last;
 	}
 }
+
+ZEND_API void zend_alloc_ce_cache(zend_string *type_name)
+{
+	if (ZSTR_HAS_CE_CACHE(type_name) || !ZSTR_IS_INTERNED(type_name)) {
+		return;
+	}
+
+	if ((GC_FLAGS(type_name) & IS_STR_PERMANENT) && startup_done) {
+		/* Don't allocate slot on permanent interned string outside module startup.
+		 * The cache slot would no longer be valid on the next request. */
+		return;
+	}
+
+	if (zend_string_equals_literal_ci(type_name, "self")
+			|| zend_string_equals_literal_ci(type_name, "parent")) {
+		return;
+	}
+
+	/* We use the refcount to keep map_ptr of corresponding type */
+	uint32_t ret;
+	do {
+		ret = (uint32_t)(uintptr_t)zend_map_ptr_new();
+	} while (ret <= 2);
+	GC_ADD_FLAGS(type_name, IS_STR_CLASS_NAME_MAP_PTR);
+	GC_SET_REFCOUNT(type_name, ret);
+}

Zend/zend_API.c

@@ -3053,6 +3053,7 @@ static zend_class_entry *do_register_internal_class(zend_class_entry *orig_class
 
 	class_entry->type = ZEND_INTERNAL_CLASS;
 	zend_initialize_class_data(class_entry, 0);
+	zend_alloc_ce_cache(class_entry->name);
 	class_entry->ce_flags = orig_class_entry->ce_flags | ce_flags | ZEND_ACC_CONSTANTS_UPDATED | ZEND_ACC_LINKED | ZEND_ACC_RESOLVED_PARENT | ZEND_ACC_RESOLVED_INTERFACES;
 	class_entry->info.internal.module = EG(current_module);
 
@@ -4126,6 +4127,17 @@ ZEND_API zend_property_info *zend_declare_typed_property(zend_class_entry *ce, z
 	property_info->ce = ce;
 	property_info->type = type;
 
+	if (is_persistent_class(ce)) {
+		zend_type *single_type;
+		ZEND_TYPE_FOREACH(property_info->type, single_type) {
+			if (ZEND_TYPE_HAS_NAME(*single_type)) {
+				zend_string *name = zend_new_interned_string(ZEND_TYPE_NAME(*single_type));
+				ZEND_TYPE_SET_PTR(*single_type, name);
+				zend_alloc_ce_cache(name);
+			}
+		} ZEND_TYPE_FOREACH_END();
+	}
+
 	zend_hash_update_ptr(&ce->properties_info, name, property_info);
 
 	return property_info;

Zend/zend_compile.c

@@ -1202,43 +1202,13 @@ zend_string *zend_type_to_string_resolved(zend_type type, zend_class_entry *scop
 		zend_type *list_type;
 		bool is_intersection = ZEND_TYPE_IS_INTERSECTION(type);
 		ZEND_TYPE_LIST_FOREACH(ZEND_TYPE_LIST(type), list_type) {
-			if (ZEND_TYPE_HAS_CE(*list_type)) {
-				str = add_type_string(str, ZEND_TYPE_CE(*list_type)->name, is_intersection);
-			} else {
-				zend_string *name = ZEND_TYPE_NAME(*list_type);
-
-				if (ZSTR_HAS_CE_CACHE(name)
-				 && ZSTR_GET_CE_CACHE(name)) {
-					zend_class_entry *ce = ZSTR_GET_CE_CACHE(name);
-					if (ce->ce_flags & ZEND_ACC_ANON_CLASS) {
-						zend_string *tmp = zend_string_init(ZSTR_VAL(ce->name), strlen(ZSTR_VAL(ce->name)), 0);
-						str = add_type_string(str, tmp, is_intersection);
-					} else {
-						str = add_type_string(str, ce->name, is_intersection);
-					}
-				} else {
-					zend_string *resolved = resolve_class_name(name, scope);
-					str = add_type_string(str, resolved, is_intersection);
-					zend_string_release(resolved);
-				}
-			}
+			zend_string *name = ZEND_TYPE_NAME(*list_type);
+			zend_string *resolved = resolve_class_name(name, scope);
+			str = add_type_string(str, resolved, is_intersection);
+			zend_string_release(resolved);
 		} ZEND_TYPE_LIST_FOREACH_END();
 	} else if (ZEND_TYPE_HAS_NAME(type)) {
-		zend_string *name = ZEND_TYPE_NAME(type);
-
-		if (ZSTR_HAS_CE_CACHE(name)
-		 && ZSTR_GET_CE_CACHE(name)) {
-			zend_class_entry *ce = ZSTR_GET_CE_CACHE(name);
-			if (ce->ce_flags & ZEND_ACC_ANON_CLASS) {
-				str = zend_string_init(ZSTR_VAL(ce->name), strlen(ZSTR_VAL(ce->name)), 0);
-			} else {
-				str = zend_string_copy(ce->name);
-			}
-		} else {
-			str = resolve_class_name(name, scope);
-		}
-	} else if (ZEND_TYPE_HAS_CE(type)) {
-		str = zend_string_copy(ZEND_TYPE_CE(type)->name);
+		str = resolve_class_name(ZEND_TYPE_NAME(type), scope);
 	}
 
 	uint32_t type_mask = ZEND_TYPE_PURE_MASK(type);
@@ -6232,6 +6202,8 @@ static zend_type zend_compile_single_typename(zend_ast *ast)
 				}
 			}
 
+			class_name = zend_new_interned_string(class_name);
+			zend_alloc_ce_cache(class_name);
 			return (zend_type) ZEND_TYPE_INIT_CLASS(class_name, 0, 0);
 		}
 	}
@@ -7687,6 +7659,9 @@ void zend_compile_class_decl(znode *result, zend_ast *ast, bool toplevel) /* {{{
 	ce->type = ZEND_USER_CLASS;
 	ce->name = name;
 	zend_initialize_class_data(ce, 1);
+	if (!(decl->flags & ZEND_ACC_ANON_CLASS)) {
+		zend_alloc_ce_cache(ce->name);
+	}
 
 	if (CG(compiler_options) & ZEND_COMPILE_PRELOAD) {
 		ce->ce_flags |= ZEND_ACC_PRELOADED;

Zend/zend_execute.c

@@ -851,11 +851,6 @@ ZEND_API ZEND_COLD void ZEND_FASTCALL zend_readonly_property_modification_error(
 
 static zend_class_entry *resolve_single_class_type(zend_string *name, zend_class_entry *self_ce) {
 	if (zend_string_equals_literal_ci(name, "self")) {
-		/* We need to explicitly check for this here, to avoid updating the type in the trait and
-		 * later using the wrong "self" when the trait is used in a class. */
-		if (UNEXPECTED((self_ce->ce_flags & ZEND_ACC_TRAIT) != 0)) {
-			return NULL;
-		}
 		return self_ce;
 	} else if (zend_string_equals_literal_ci(name, "parent")) {
 		return self_ce->parent;
@@ -866,26 +861,16 @@ static zend_class_entry *resolve_single_class_type(zend_string *name, zend_class
 
 static zend_always_inline zend_class_entry *zend_ce_from_type(
 		zend_property_info *info, zend_type *type) {
-	if (UNEXPECTED(!ZEND_TYPE_HAS_NAME(*type))) {
-		ZEND_ASSERT(ZEND_TYPE_HAS_CE(*type));
-		return ZEND_TYPE_CE(*type);
-	}
-
+	ZEND_ASSERT(ZEND_TYPE_HAS_NAME(*type));
 	zend_string *name = ZEND_TYPE_NAME(*type);
-	zend_class_entry *ce;
 	if (ZSTR_HAS_CE_CACHE(name)) {
-		ce = ZSTR_GET_CE_CACHE(name);
+		zend_class_entry *ce = ZSTR_GET_CE_CACHE(name);
 		if (!ce) {
 			ce = zend_lookup_class_ex(name, NULL, ZEND_FETCH_CLASS_NO_AUTOLOAD);
 		}
-	} else {
-		ce = resolve_single_class_type(name, info->ce);
-		if (ce && !(info->ce->ce_flags & ZEND_ACC_IMMUTABLE)) {
-			zend_string_release(name);
-			ZEND_TYPE_SET_CE(*type, ce);
-		}
+		return ce;
 	}
-	return ce;
+	return resolve_single_class_type(name, info->ce);
 }
 
 static bool zend_check_and_resolve_property_class_type(

Zend/zend_inheritance.c

@@ -430,9 +430,6 @@ static inheritance_status zend_is_intersection_subtype_of_class(
 
 			if (!proto_ce) proto_ce = lookup_class(proto_scope, proto_class_name);
 			fe_ce = lookup_class(fe_scope, fe_class_name);
-		} else if (ZEND_TYPE_HAS_CE(*single_type)) {
-			if (!proto_ce) proto_ce = lookup_class(proto_scope, proto_class_name);
-			fe_ce = ZEND_TYPE_CE(*single_type);
 		} else {
 			/* standard type in an intersection type is impossible,
 			 * because it would be a fatal compile error */
@@ -456,8 +453,9 @@ static inheritance_status zend_is_intersection_subtype_of_class(
 
 /* Check whether a single class proto type is a subtype of a potentially complex fe_type. */
 static inheritance_status zend_is_class_subtype_of_type(
-		zend_class_entry *fe_scope, zend_string *fe_class_name, zend_class_entry *fe_ce,
+		zend_class_entry *fe_scope, zend_string *fe_class_name,
 		zend_class_entry *proto_scope, zend_type proto_type) {
+	zend_class_entry *fe_ce = NULL;
 	bool have_unresolved = 0;
 
 	/* If the parent has 'object' as a return type, any class satisfies the co-variant check */
@@ -503,9 +501,6 @@ static inheritance_status zend_is_class_subtype_of_type(
 
 			if (!fe_ce) fe_ce = lookup_class(fe_scope, fe_class_name);
 			proto_ce = lookup_class(proto_scope, proto_class_name);
-		} else if (ZEND_TYPE_HAS_CE(*single_type)) {
-			if (!fe_ce) fe_ce = lookup_class(fe_scope, fe_class_name);
-			proto_ce = ZEND_TYPE_CE(*single_type);
 		} else {
 			/* standard type */
 			ZEND_ASSERT(!is_intersection);
@@ -535,16 +530,10 @@ static inheritance_status zend_is_class_subtype_of_type(
 	return is_intersection ? INHERITANCE_SUCCESS : INHERITANCE_ERROR;
 }
 
-static zend_string *get_class_from_type(
-		zend_class_entry **ce, zend_class_entry *scope, zend_type single_type) {
+static zend_string *get_class_from_type(zend_class_entry *scope, zend_type single_type) {
 	if (ZEND_TYPE_HAS_NAME(single_type)) {
-		*ce = NULL;
 		return resolve_class_name(scope, ZEND_TYPE_NAME(single_type));
 	}
-	if (ZEND_TYPE_HAS_CE(single_type)) {
-		*ce = ZEND_TYPE_CE(single_type);
-		return (*ce)->name;
-	}
 	return NULL;
 }
 
@@ -617,14 +606,11 @@ static inheritance_status zend_perform_covariant_type_check(
 		if (proto_type_mask & (MAY_BE_OBJECT|MAY_BE_ITERABLE)) {
 			bool any_class = (proto_type_mask & MAY_BE_OBJECT) != 0;
 			ZEND_TYPE_FOREACH(fe_type, single_type) {
-				zend_class_entry *fe_ce;
-				zend_string *fe_class_name = get_class_from_type(&fe_ce, fe_scope, *single_type);
+				zend_string *fe_class_name = get_class_from_type(fe_scope, *single_type);
 				if (!fe_class_name) {
 					continue;
 				}
-				if (!fe_ce) {
-					fe_ce = lookup_class(fe_scope, fe_class_name);
-				}
+				zend_class_entry *fe_ce = lookup_class(fe_scope, fe_class_name);
 				if (fe_ce) {
 					if (any_class || unlinked_instanceof(fe_ce, zend_ce_traversable)) {
 						track_class_dependency(fe_ce, fe_class_name);
@@ -643,13 +629,12 @@ static inheritance_status zend_perform_covariant_type_check(
 		early_exit_status =
 			ZEND_TYPE_IS_INTERSECTION(proto_type) ? INHERITANCE_ERROR : INHERITANCE_SUCCESS;
 		ZEND_TYPE_FOREACH(proto_type, single_type) {
-			zend_class_entry *proto_ce;
-			zend_string *proto_class_name =
-				get_class_from_type(&proto_ce, proto_scope, *single_type);
+			zend_string *proto_class_name = get_class_from_type(proto_scope, *single_type);
 			if (!proto_class_name) {
 				continue;
 			}
 
+			zend_class_entry *proto_ce = NULL;
 			inheritance_status status = zend_is_intersection_subtype_of_class(
 				fe_scope, fe_type, proto_scope, proto_class_name, proto_ce);
 			if (status == early_exit_status) {
@@ -666,14 +651,13 @@ static inheritance_status zend_perform_covariant_type_check(
 		 * whether proto_type is a union or intersection (only the inner check differs). */
 		early_exit_status = INHERITANCE_ERROR;
 		ZEND_TYPE_FOREACH(fe_type, single_type) {
-			zend_class_entry *fe_ce;
-			zend_string *fe_class_name = get_class_from_type(&fe_ce, fe_scope, *single_type);
+			zend_string *fe_class_name = get_class_from_type(fe_scope, *single_type);
 			if (!fe_class_name) {
 				continue;
 			}
 
 			inheritance_status status = zend_is_class_subtype_of_type(
-				fe_scope, fe_class_name, fe_ce, proto_scope, proto_type);
+				fe_scope, fe_class_name, proto_scope, proto_type);
 			if (status == early_exit_status) {
 				return status;
 			}

Zend/zend_map_ptr.h

@@ -103,5 +103,6 @@
 ZEND_API void  zend_map_ptr_reset(void);
 ZEND_API void *zend_map_ptr_new(void);
 ZEND_API void  zend_map_ptr_extend(size_t last);
+ZEND_API void zend_alloc_ce_cache(zend_string *type_name);
 
 #endif /* ZEND_MAP_PTR_H */