Fast Class Cache

Zend/tests/return_types/inheritance001.phpt

@@ -8,8 +8,8 @@ class A {
 }
 
 class B extends A {
-    function foo(): StdClass {}
+    function foo(): stdClass {}
 }
 ?>
 --EXPECTF--
-Fatal error: Declaration of B::foo(): StdClass must be compatible with A::foo(): A in %s on line %d
+Fatal error: Declaration of B::foo(): stdClass must be compatible with A::foo(): A in %s on line %d

Zend/tests/return_types/inheritance002.phpt

@@ -8,8 +8,8 @@ abstract class A {
 }
 
 class B extends A {
-    function foo(): StdClass {}
+    function foo(): stdClass {}
 }
 ?>
 --EXPECTF--
-Fatal error: Declaration of B::foo(): StdClass must be compatible with A::foo(): A in %s on line %d
+Fatal error: Declaration of B::foo(): stdClass must be compatible with A::foo(): A in %s on line %d

Zend/tests/return_types/inheritance003.phpt

@@ -8,8 +8,8 @@ interface A {
 }
 
 class B implements A {
-    function foo(): StdClass {}
+    function foo(): stdClass {}
 }
 ?>
 --EXPECTF--
-Fatal error: Declaration of B::foo(): StdClass must be compatible with A::foo(): A in %s on line %d
+Fatal error: Declaration of B::foo(): stdClass must be compatible with A::foo(): A in %s on line %d

Zend/zend_builtin_functions.c

@@ -995,6 +995,13 @@ static inline void class_exists_impl(INTERNAL_FUNCTION_PARAMETERS, int flags, in
 		Z_PARAM_BOOL(autoload)
 	ZEND_PARSE_PARAMETERS_END();
 
+	if (ZSTR_HAS_CE_CACHE(name)) {
+		ce = ZSTR_GET_CE_CACHE(name);
+		if (ce) {
+			RETURN_BOOL(((ce->ce_flags & flags) == flags) && !(ce->ce_flags & skip_flags));
+		}
+	}
+
 	if (!autoload) {
 		if (ZSTR_VAL(name)[0] == '\\') {
 			/* Ignore leading "\" */

Zend/zend_compile.c

@@ -1197,33 +1197,37 @@ zend_string *zend_type_to_string_resolved(zend_type type, zend_class_entry *scop
 			if (ZEND_TYPE_HAS_CE(*list_type)) {
 				str = add_type_string(str, ZEND_TYPE_CE(*list_type)->name);
 			} else {
-				if (ZEND_TYPE_HAS_CE_CACHE(*list_type)
-				 && ZEND_TYPE_CE_CACHE(*list_type)) {
-					zend_class_entry *ce = ZEND_TYPE_CE_CACHE(*list_type);
+				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);
 					} else {
 						str = add_type_string(str, ce->name);
 					}
 				} else {
-					zend_string *resolved = resolve_class_name(ZEND_TYPE_NAME(*list_type), scope);
+					zend_string *resolved = resolve_class_name(name, scope);
 					str = add_type_string(str, resolved);
 					zend_string_release(resolved);
 				}
 			}
 		} ZEND_TYPE_LIST_FOREACH_END();
 	} else if (ZEND_TYPE_HAS_NAME(type)) {
-		if (ZEND_TYPE_HAS_CE_CACHE(type)
-		 && ZEND_TYPE_CE_CACHE(type)) {
-			zend_class_entry *ce = ZEND_TYPE_CE_CACHE(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(ZEND_TYPE_NAME(type), scope);
+			str = resolve_class_name(name, scope);
 		}
 	} else if (ZEND_TYPE_HAS_CE(type)) {
 		str = zend_string_copy(ZEND_TYPE_CE(type)->name);

Zend/zend_execute.c

@@ -852,24 +852,25 @@ static bool zend_check_and_resolve_property_class_type(
 		zend_type *list_type;
 		ZEND_TYPE_LIST_FOREACH(ZEND_TYPE_LIST(info->type), list_type) {
 			if (ZEND_TYPE_HAS_NAME(*list_type)) {
-				if (ZEND_TYPE_HAS_CE_CACHE(*list_type)) {
-					ce = ZEND_TYPE_CE_CACHE(*list_type);
+				zend_string *name = ZEND_TYPE_NAME(*list_type);
+
+				if (ZSTR_HAS_CE_CACHE(name)) {
+					ce = ZSTR_GET_CE_CACHE(name);
 					if (!ce) {
-						zend_string *name = ZEND_TYPE_NAME(*list_type);
-						ce = resolve_single_class_type(name, info->ce);
+						ce = zend_lookup_class_ex(name, NULL, ZEND_FETCH_CLASS_NO_AUTOLOAD);
 						if (UNEXPECTED(!ce)) {
 							continue;
 						}
-						ZEND_TYPE_SET_CE_CACHE(*list_type, ce);
 					}
 				} else {
-					zend_string *name = ZEND_TYPE_NAME(*list_type);
 					ce = resolve_single_class_type(name, info->ce);
 					if (!ce) {
 						continue;
 					}
-					zend_string_release(name);
-					ZEND_TYPE_SET_CE(*list_type, ce);
+					if (!(info->ce->ce_flags & ZEND_ACC_IMMUTABLE)) {
+						zend_string_release(name);
+						ZEND_TYPE_SET_CE(*list_type, ce);
+					}
 				}
 			} else {
 				ce = ZEND_TYPE_CE(*list_type);
@@ -881,25 +882,25 @@ static bool zend_check_and_resolve_property_class_type(
 		return 0;
 	} else {
 		if (UNEXPECTED(ZEND_TYPE_HAS_NAME(info->type))) {
-			if (ZEND_TYPE_HAS_CE_CACHE(info->type)) {
-				ce = ZEND_TYPE_CE_CACHE(info->type);
+			zend_string *name = ZEND_TYPE_NAME(info->type);
+
+			if (ZSTR_HAS_CE_CACHE(name)) {
+				ce = ZSTR_GET_CE_CACHE(name);
 				if (!ce) {
-					zend_string *name = ZEND_TYPE_NAME(info->type);
-					ce = resolve_single_class_type(name, info->ce);
+					ce = zend_lookup_class_ex(name, NULL, ZEND_FETCH_CLASS_NO_AUTOLOAD);
 					if (UNEXPECTED(!ce)) {
 						return 0;
 					}
-					ZEND_TYPE_SET_CE_CACHE(info->type, ce);
 				}
 			} else {
-				zend_string *name = ZEND_TYPE_NAME(info->type);
 				ce = resolve_single_class_type(name, info->ce);
 				if (UNEXPECTED(!ce)) {
 					return 0;
 				}
-
-				zend_string_release(name);
-				ZEND_TYPE_SET_CE(info->type, ce);
+				if (!(info->ce->ce_flags & ZEND_ACC_IMMUTABLE)) {
+					zend_string_release(name);
+					ZEND_TYPE_SET_CE(info->type, ce);
+				}
 			}
 		} else {
 			ce = ZEND_TYPE_CE(info->type);
@@ -989,26 +990,33 @@ static zend_always_inline bool zend_check_type_slow(
 			ZEND_TYPE_LIST_FOREACH(ZEND_TYPE_LIST(*type), list_type) {
 				if (HAVE_CACHE_SLOT && *cache_slot) {
 					ce = *cache_slot;
-				} else if (ZEND_TYPE_HAS_CE_CACHE(*list_type) && ZEND_TYPE_CE_CACHE(*list_type)) {
-					ce = ZEND_TYPE_CE_CACHE(*list_type);
-					if (HAVE_CACHE_SLOT) {
-						*cache_slot = ce;
-					}
 				} else {
-					ce = zend_fetch_class(ZEND_TYPE_NAME(*list_type),
-						ZEND_FETCH_CLASS_AUTO | ZEND_FETCH_CLASS_NO_AUTOLOAD | ZEND_FETCH_CLASS_SILENT);
-					if (!ce) {
-						if (HAVE_CACHE_SLOT) {
-							cache_slot++;
+					zend_string *name = ZEND_TYPE_NAME(*list_type);
+
+					if (ZSTR_HAS_CE_CACHE(name)) {
+						ce = ZSTR_GET_CE_CACHE(name);
+						if (!ce) {
+							ce = zend_lookup_class_ex(name, NULL, ZEND_FETCH_CLASS_NO_AUTOLOAD);
+							if (!ce) {
+								if (HAVE_CACHE_SLOT) {
+									cache_slot++;
+								}
+								continue;
+							}
+						}
+					} else {
+						ce = zend_fetch_class(name,
+							ZEND_FETCH_CLASS_AUTO | ZEND_FETCH_CLASS_NO_AUTOLOAD | ZEND_FETCH_CLASS_SILENT);
+						if (!ce) {
+							if (HAVE_CACHE_SLOT) {
+								cache_slot++;
+							}
+							continue;
 						}
-						continue;
 					}
 					if (HAVE_CACHE_SLOT) {
 						*cache_slot = ce;
 					}
-					if (ZEND_TYPE_HAS_CE_CACHE(*list_type)) {
-						ZEND_TYPE_SET_CE_CACHE(*list_type, ce);
-					}
 				}
 				if (instanceof_function(Z_OBJCE_P(arg), ce)) {
 					return 1;
@@ -1020,23 +1028,27 @@ static zend_always_inline bool zend_check_type_slow(
 		} else {
 			if (EXPECTED(HAVE_CACHE_SLOT && *cache_slot)) {
 				ce = (zend_class_entry *) *cache_slot;
-			} else if (ZEND_TYPE_HAS_CE_CACHE(*type) && ZEND_TYPE_CE_CACHE(*type)) {
-				ce = ZEND_TYPE_CE_CACHE(*type);
-				if (HAVE_CACHE_SLOT) {
-					*cache_slot = ce;
-				}
 			} else {
-				ce = zend_fetch_class(ZEND_TYPE_NAME(*type),
-					ZEND_FETCH_CLASS_AUTO | ZEND_FETCH_CLASS_NO_AUTOLOAD | ZEND_FETCH_CLASS_SILENT);
-				if (UNEXPECTED(!ce)) {
-					goto builtin_types;
+				zend_string *name = ZEND_TYPE_NAME(*type);
+
+				if (ZSTR_HAS_CE_CACHE(name)) {
+					ce = ZSTR_GET_CE_CACHE(name);
+					if (!ce) {
+						ce = zend_lookup_class_ex(name, NULL, ZEND_FETCH_CLASS_NO_AUTOLOAD);
+						if (UNEXPECTED(!ce)) {
+							goto builtin_types;
+						}
+					}
+				} else {
+					ce = zend_fetch_class(name,
+						ZEND_FETCH_CLASS_AUTO | ZEND_FETCH_CLASS_NO_AUTOLOAD | ZEND_FETCH_CLASS_SILENT);
+					if (UNEXPECTED(!ce)) {
+						goto builtin_types;
+					}
 				}
 				if (HAVE_CACHE_SLOT) {
 					*cache_slot = (void *) ce;
 				}
-				if (ZEND_TYPE_HAS_CE_CACHE(*type)) {
-					ZEND_TYPE_SET_CE_CACHE(*type, ce);
-				}
 			}
 			if (instanceof_function(Z_OBJCE_P(arg), ce)) {
 				return 1;

Zend/zend_execute_API.c

@@ -1054,6 +1054,13 @@ ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, zend_string *
 	zend_string *lc_name;
 	zend_string *autoload_name;
 
+	if (ZSTR_HAS_CE_CACHE(name)) {
+		ce = ZSTR_GET_CE_CACHE(name);
+		if (ce) {
+			return ce;
+		}
+	}
+
 	if (key) {
 		lc_name = key;
 	} else {
@@ -1092,6 +1099,9 @@ ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, zend_string *
 			}
 			return NULL;
 		}
+		if (ZSTR_HAS_CE_CACHE(name)) {
+			ZSTR_SET_CE_CACHE(name, ce);
+		}
 		return ce;
 	}
 
@@ -1144,6 +1154,11 @@ ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, zend_string *
 	if (!key) {
 		zend_string_release_ex(lc_name, 0);
 	}
+	if (ce) {
+		if (ZSTR_HAS_CE_CACHE(name)) {
+			ZSTR_SET_CE_CACHE(name, ce);
+		}
+	}
 	return ce;
 }
 /* }}} */

Zend/zend_inheritance.c

@@ -2682,6 +2682,9 @@ ZEND_API zend_class_entry *zend_do_link_class(zend_class_entry *ce, zend_string
 					}
 					zv = zend_hash_find_ex(CG(class_table), key, 1);
 					Z_CE_P(zv) = ret;
+					if (ZSTR_HAS_CE_CACHE(ret->name)) {
+						ZSTR_SET_CE_CACHE(ret->name, ret);
+					}
 					return ret;
 				}
 			} else {
@@ -2803,6 +2806,10 @@ ZEND_API zend_class_entry *zend_do_link_class(zend_class_entry *ce, zend_string
 		free_alloca(traits_and_interfaces, use_heap);
 	}
 
+	if (ZSTR_HAS_CE_CACHE(ce->name)) {
+		ZSTR_SET_CE_CACHE(ce->name, ce);
+	}
+
 	return ce;
 }
 /* }}} */
@@ -2875,6 +2882,9 @@ zend_class_entry *zend_try_early_bind(zend_class_entry *ce, zend_class_entry *pa
 						return NULL;
 					}
 				}
+				if (ZSTR_HAS_CE_CACHE(ret->name)) {
+					ZSTR_SET_CE_CACHE(ret->name, ret);
+				}
 				return ret;
 			}
 		} else {
@@ -2942,6 +2952,10 @@ zend_class_entry *zend_try_early_bind(zend_class_entry *ce, zend_class_entry *pa
 			}
 		}
 
+		if (ZSTR_HAS_CE_CACHE(ce->name)) {
+			ZSTR_SET_CE_CACHE(ce->name, ce);
+		}
+
 		return ce;
 	}
 	return NULL;

Zend/zend_map_ptr.h

@@ -55,34 +55,34 @@
 # define ZEND_MAP_PTR_SET_REAL_BASE(base, ptr) do { \
 		base = (ptr); \
 	} while (0)
-# define ZEND_MAP_PTR_OFFSET2PTR(ptr) \
-	((void**)((char*)CG(map_ptr_base) + (uintptr_t)ZEND_MAP_PTR(ptr)))
+# define ZEND_MAP_PTR_OFFSET2PTR(offset) \
+	((void**)((char*)CG(map_ptr_base) + offset))
 #elif ZEND_MAP_PTR_KIND == ZEND_MAP_PTR_KIND_PTR_OR_OFFSET
 # define ZEND_MAP_PTR(ptr) \
 	ptr ## __ptr
 # define ZEND_MAP_PTR_DEF(type, name) \
 	type * ZEND_MAP_PTR(name)
 # define ZEND_MAP_PTR_IS_OFFSET(ptr) \
 	(((uintptr_t)ZEND_MAP_PTR(ptr)) & 1L)
-# define ZEND_MAP_PTR_OFFSET2PTR(ptr) \
-	((void**)((char*)CG(map_ptr_base) + (uintptr_t)ZEND_MAP_PTR(ptr)))
+# define ZEND_MAP_PTR_OFFSET2PTR(offset) \
+	((void**)((char*)CG(map_ptr_base) + offset))
 # define ZEND_MAP_PTR_PTR2OFFSET(ptr) \
 	((void*)(((char*)(ptr)) - ((char*)CG(map_ptr_base))))
 # define ZEND_MAP_PTR_GET(ptr) \
 	(*(ZEND_MAP_PTR_IS_OFFSET(ptr) ? \
-		ZEND_MAP_PTR_OFFSET2PTR(ptr) : \
+		ZEND_MAP_PTR_OFFSET2PTR((uintptr_t)ZEND_MAP_PTR(ptr)) : \
 		((void**)(ZEND_MAP_PTR(ptr)))))
 # define ZEND_MAP_PTR_GET_IMM(ptr) \
-	(*ZEND_MAP_PTR_OFFSET2PTR(ptr))
+	(*ZEND_MAP_PTR_OFFSET2PTR((uintptr_t)ZEND_MAP_PTR(ptr)))
 # define ZEND_MAP_PTR_SET(ptr, val) do { \
 		void **__p = (void**)(ZEND_MAP_PTR(ptr)); \
 		if (ZEND_MAP_PTR_IS_OFFSET(ptr)) { \
-			__p = ZEND_MAP_PTR_OFFSET2PTR(ptr); \
+			__p = ZEND_MAP_PTR_OFFSET2PTR((uintptr_t)ZEND_MAP_PTR(ptr)); \
 		} \
 		*__p = (val); \
 	} while (0)
 # define ZEND_MAP_PTR_SET_IMM(ptr, val) do { \
-		void **__p = ZEND_MAP_PTR_OFFSET2PTR(ptr); \
+		void **__p = ZEND_MAP_PTR_OFFSET2PTR((uintptr_t)ZEND_MAP_PTR(ptr)); \
 		*__p = (val); \
 	} while (0)
 # define ZEND_MAP_PTR_INIT(ptr, val) do { \