Opcache support

Author: arnaud-lb

Zend/Optimizer/compact_literals.c

@@ -24,8 +24,11 @@
 #include "Optimizer/zend_optimizer.h"
 #include "Optimizer/zend_optimizer_internal.h"
 #include "zend_API.h"
+#include "zend_compile.h"
 #include "zend_constants.h"
 #include "zend_execute.h"
+#include "zend_string.h"
+#include "zend_types.h"
 #include "zend_vm.h"
 #include "zend_extensions.h"
 
@@ -35,6 +38,9 @@
 #define LITERAL_STATIC_METHOD 2
 #define LITERAL_STATIC_PROPERTY 3
 
+// TODO: temp hack
+#define LITERAL_PNR_AND_KEY (1<<7)
+
 typedef struct _literal_info {
 	uint8_t num_related;
 } literal_info;
@@ -245,7 +251,7 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
 					break;
 				case ZEND_NEW:
 					if (opline->op1_type == IS_CONST) {
-						LITERAL_INFO(opline->op1.constant, 2);
+						LITERAL_INFO(opline->op1.constant, 2 | LITERAL_PNR_AND_KEY);
 					}
 					break;
 				case ZEND_DECLARE_CLASS:
@@ -312,6 +318,10 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
 		memset(map, 0, op_array->last_literal * sizeof(int));
 		for (i = 0; i < op_array->last_literal; i++) {
 			if (!info[i].num_related) {
+				// TODO: temp hack
+				if (Z_TYPE(op_array->literals[i]) == IS_PNR) {
+					zend_pnr_destroy(Z_PNR(op_array->literals[i]));
+				}
 				/* unset literal */
 				zval_ptr_dtor_nogc(&op_array->literals[i]);
 				continue;
@@ -443,6 +453,67 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
 					}
 					break;
 				}
+				case IS_PNR: {
+					ZEND_ASSERT(info[i].num_related & LITERAL_PNR_AND_KEY);
+					ZEND_ASSERT(Z_TYPE(op_array->literals[i+1]) == IS_STRING);
+
+					uint8_t num_related = info[i].num_related & ~LITERAL_PNR_AND_KEY;
+					ZEND_ASSERT(num_related == 2);
+
+					zend_packed_name_reference pnr = Z_PNR(op_array->literals[i]);
+					zend_string *base_key = Z_STR(op_array->literals[i+1]);
+					zend_string *key;
+					if (ZEND_PNR_IS_COMPLEX(pnr)) {
+						key = ZEND_PNR_COMPLEX_GET_KEY(pnr);
+					} else {
+						key = ZEND_PNR_SIMPLE_GET_NAME(pnr);
+					}
+					key = zend_string_concat2(
+							ZSTR_VAL(key), ZSTR_LEN(key)+1,
+							ZSTR_VAL(base_key), ZSTR_LEN(base_key));
+					bias_key(key, 300 + num_related - 1);
+
+					if ((pos = zend_hash_find(&hash, key)) != NULL) {
+						ZEND_ASSERT(Z_TYPE(op_array->literals[Z_LVAL_P(pos)]) == IS_PNR &&
+							Z_TYPE(op_array->literals[Z_LVAL_P(pos)+1]) == IS_STRING &&
+							info[i].num_related == info[Z_LVAL_P(pos)].num_related);
+						zend_string_release_ex(key, 0);
+						map[i] = Z_LVAL_P(pos);
+						zend_packed_name_reference pnr2 = Z_PNR(op_array->literals[i]);
+						if (ZEND_PNR_IS_SIMPLE(pnr2)) {
+							zend_string_release(ZEND_PNR_SIMPLE_GET_NAME(pnr2));
+						} else {
+							zend_name_reference *class_ref = ZEND_PNR_COMPLEX_GET_REF(pnr2);
+							zend_string_release(class_ref->name);
+							zend_string_release(class_ref->key);
+						}
+						n = num_related;
+						while (n > 1) {
+							i++;
+							zval_ptr_dtor_nogc(&op_array->literals[i]);
+							n--;
+						}
+					} else {
+						map[i] = j;
+						ZVAL_LONG(&zv, j);
+						zend_hash_add_new(&hash, key, &zv);
+						zend_string_release_ex(key, 0);
+						if (i != j) {
+							op_array->literals[j] = op_array->literals[i];
+							info[j] = info[i];
+						}
+						j++;
+						n = num_related;
+						while (n > 1) {
+							i++;
+							if (i != j) op_array->literals[j] = op_array->literals[i];
+							j++;
+							n--;
+						}
+					}
+
+					break;
+				}
 				case IS_ARRAY:
 					ZEND_ASSERT(info[i].num_related == 1);
 					if (zend_hash_num_elements(Z_ARRVAL(op_array->literals[i])) == 0) {

Zend/Optimizer/zend_dump.c

@@ -23,7 +23,9 @@
 #include "zend_func_info.h"
 #include "zend_call_graph.h"
 #include "zend_dump.h"
+#include "zend_smart_str.h"
 #include "ext/standard/php_string.h"
+#include "zend_types.h"
 
 void zend_dump_ht(HashTable *ht)
 {
@@ -76,6 +78,39 @@ void zend_dump_const(const zval *zv)
 		case IS_ARRAY:
 			fprintf(stderr, " array(...)");
 			break;
+		case IS_PNR: {
+			zend_packed_name_reference pnr = Z_PNR_P(zv);
+			zend_string *name;
+			const zend_type_list *type_args;
+			ZEND_PNR_UNPACK(pnr, name, type_args);
+
+			smart_str str = {0};
+			smart_str_append(&str, name);
+
+			if (type_args != &zend_empty_type_list) {
+				smart_str_appendc(&str, '<');
+				zend_type *single_type;
+				ZEND_TYPE_LIST_FOREACH((zend_type_list*)type_args, single_type) {
+					if (single_type != type_args->types) {
+						smart_str_appendc(&str, ',');
+					}
+					zend_string *type_str = zend_type_to_string(*single_type, NULL);
+					smart_str_append(&str, type_str);
+					zend_string_release(type_str);
+				} ZEND_TYPE_LIST_FOREACH_END();
+				smart_str_appendc(&str, '>');
+			}
+
+			name = smart_str_extract(&str);
+			zend_string *escaped_string = php_addcslashes(name, "\0..\37\"\\\177..\377", 2);
+			zend_string_release(name);
+
+			fprintf(stderr, " pnr(\"%s\")", ZSTR_VAL(escaped_string));
+
+			zend_string_release(escaped_string);
+
+			break;
+		}
 		default:
 			fprintf(stderr, " zval(type=%d)", Z_TYPE_P(zv));
 			break;

Zend/Optimizer/zend_inference.h

@@ -148,6 +148,8 @@ END_EXTERN_C()
 static zend_always_inline uint32_t _const_op_type(const zval *zv) {
 	if (Z_TYPE_P(zv) == IS_CONSTANT_AST) {
 		return MAY_BE_RC1 | MAY_BE_RCN | MAY_BE_ANY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_ANY;
+	} else if (Z_TYPE_P(zv) == IS_PNR) {
+		return MAY_BE_STRING;
 	} else if (Z_TYPE_P(zv) == IS_ARRAY) {
 		return zend_array_type_info(zv);
 	} else {

Zend/Optimizer/zend_optimizer.c

@@ -24,6 +24,7 @@
 #include "zend_API.h"
 #include "zend_constants.h"
 #include "zend_execute.h"
+#include "zend_types.h"
 #include "zend_vm.h"
 #include "zend_cfg.h"
 #include "zend_func_info.h"
@@ -323,11 +324,13 @@ bool zend_optimizer_update_op1_const(zend_op_array *op_array,
 			zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
 			break;
 		case ZEND_NEW:
-			REQUIRES_STRING(val);
-			drop_leading_backslash(val);
+			if (Z_TYPE_P(val) != IS_PNR) {
+				return 0;
+			}
+			// TODO drop_leading_backslash(val);
 			opline->op1.constant = zend_optimizer_add_literal(op_array, val);
 			opline->op2.num = alloc_cache_slots(op_array, 1);
-			zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
+			zend_optimizer_add_literal_string(op_array, zend_string_tolower(ZEND_PNR_GET_NAME(Z_PNR_P(val))));
 			break;
 		case ZEND_INIT_STATIC_METHOD_CALL:
 			REQUIRES_STRING(val);
@@ -816,9 +819,9 @@ zend_class_entry *zend_optimizer_get_class_entry_from_op1(
 		const zend_script *script, const zend_op_array *op_array, const zend_op *opline) {
 	if (opline->op1_type == IS_CONST) {
 		zval *op1 = CRT_CONSTANT(opline->op1);
-		if (Z_TYPE_P(op1) == IS_STRING) {
-			return zend_optimizer_get_class_entry(script, op_array, Z_STR_P(op1 + 1));
-		}
+		ZEND_ASSERT(Z_TYPE_P(op1) == IS_PNR || Z_TYPE_P(op1) == IS_STRING);
+		ZEND_ASSERT(Z_TYPE_P(op1 + 1) == IS_STRING);
+		return zend_optimizer_get_class_entry(script, op_array, Z_STR_P(op1 + 1));
 	} else if (opline->op1_type == IS_UNUSED && op_array->scope
 			&& !(op_array->scope->ce_flags & ZEND_ACC_TRAIT)
 			&& (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF) {

Zend/zend_compile.c

@@ -1930,6 +1930,16 @@ static zend_packed_name_reference zend_compile_pnr(
 	}
 }
 
+ZEND_API void zend_pnr_destroy(zend_packed_name_reference pnr) {
+	if (ZEND_PNR_IS_SIMPLE(pnr)) {
+		zend_string_release(ZEND_PNR_SIMPLE_GET_NAME(pnr));
+	} else {
+		zend_name_reference *name_ref = ZEND_PNR_COMPLEX_GET_REF(pnr);
+		zend_string_release(name_ref->name);
+		zend_string_release(name_ref->key);
+	}
+}
+
 static zend_packed_name_reference zend_compile_default_pnr(
 		zend_ast *class_ast, const char *type) {
 	zend_ast *name_ast = class_ast->child[0];
@@ -8410,6 +8420,7 @@ zend_class_entry *zend_init_class_entry_header(zend_class_entry_storage *ptr, ze
 	zend_class_entry *ce = (zend_class_entry *) ((char *) ptr + ZEND_CLASS_ENTRY_HEADER_SIZE);
 	ref->ce = ce;
 	ref->key = key;
+	zend_string_addref(key);
 	ref->args.num_types = 0;
 	return ce;
 }

Zend/zend_compile.h

@@ -868,6 +868,7 @@ ZEND_API void zend_cleanup_mutable_class_data(zend_class_entry *ce);
 ZEND_API void zend_cleanup_internal_class_data(zend_class_entry *ce);
 ZEND_API void zend_type_release(zend_type type, bool persistent);
 ZEND_API zend_string *zend_create_member_string(zend_string *class_name, zend_string *member_name);
+ZEND_API void zend_pnr_destroy(zend_packed_name_reference pnr);
 
 void zend_packed_name_reference_release(zend_packed_name_reference ref, bool persistent);
 

Zend/zend_execute.h

@@ -391,7 +391,6 @@ ZEND_API zend_class_entry *zend_fetch_class(zend_string *class_name, uint32_t fe
 ZEND_API zend_class_entry *zend_fetch_class_with_scope(zend_string *class_name, uint32_t fetch_type, zend_class_entry *scope);
 ZEND_API zend_class_entry *zend_fetch_class_by_name(zend_string *class_name, zend_string *lcname, uint32_t fetch_type);
 ZEND_API zend_class_reference *zend_fetch_generic_class_by_ref(zend_name_reference *name_ref, zend_string *base_key, uint32_t fetch_type);
-ZEND_API zend_class_reference *zend_register_generic_class(zend_name_reference *name_ref, zend_class_entry *ce);
 
 ZEND_API zend_function * ZEND_FASTCALL zend_fetch_function(zend_string *name);
 ZEND_API zend_function * ZEND_FASTCALL zend_fetch_function_str(const char *name, size_t len);

Zend/zend_execute_API.c

@@ -1123,19 +1123,6 @@ ZEND_API bool zend_is_valid_class_name(zend_string *name) {
 	return 1;
 }
 
-ZEND_API zend_class_reference *zend_register_generic_class(zend_name_reference *name_ref, zend_class_entry *ce)
-{
-	zend_class_reference *class_ref = zend_build_class_reference(name_ref, ce);
-	if (!UNEXPECTED(class_ref)) {
-		return NULL;
-	}
-
-	void *ptr = zend_hash_add_ptr(&EG(generic_class_table), name_ref->key, class_ref);
-	ZEND_ASSERT(ptr);
-
-	return class_ref;
-}
-
 ZEND_API zend_class_reference *zend_lookup_generic_class(zend_name_reference *name_ref, zend_string *base_key, uint32_t flags) /* {{{ */
 {
 	zend_class_entry *ce = NULL;
@@ -1169,7 +1156,15 @@ ZEND_API zend_class_reference *zend_lookup_generic_class(zend_name_reference *na
 		return NULL;
 	}
 
-	return zend_register_generic_class(name_ref, ce);
+	zend_class_reference *class_ref = zend_build_class_reference(name_ref, ce);
+	if (!UNEXPECTED(class_ref)) {
+		return NULL;
+	}
+
+	void *ptr = zend_hash_add_ptr(&EG(generic_class_table), name_ref->key, class_ref);
+	ZEND_ASSERT(ptr);
+
+	return class_ref;
 }
 
 ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, zend_string *key, uint32_t flags) /* {{{ */

Zend/zend_inheritance.c

@@ -30,6 +30,7 @@
 #include "zend_attributes.h"
 #include "zend_constants.h"
 #include "zend_observer.h"
+#include "zend_string.h"
 #include "zend_types.h"
 
 ZEND_API zend_class_entry* (*zend_inheritance_cache_get)(zend_class_entry *ce, zend_class_entry *parent, zend_class_entry **traits_and_interfaces) = NULL;
@@ -1625,17 +1626,23 @@ static void update_parents(zend_class_entry *ce, zend_class_entry *parent_ce) {
 		pemalloc(sizeof(zend_class_reference *) * (parent_ce->num_parents + 1),
 			ce->type == ZEND_INTERNAL_CLASS);
 	if (ce->parent_name) {
+		zend_string *key;
 		if (ZEND_PNR_IS_COMPLEX(ce->parent_name)) {
 			/* Ownership of the type arguments has been taken by generic arg binding. */
 			zend_name_reference *ref = ZEND_PNR_COMPLEX_GET_REF(ce->parent_name);
 			zend_string_release(ref->name);
+			key = ZEND_PNR_COMPLEX_GET_KEY(ce->parent_name);
+			zend_string_addref(key);
 			// efree(ref);
 		} else {
 			zend_string_release(ZEND_PNR_SIMPLE_GET_NAME(ce->parent_name));
+			key = ZEND_CE_TO_REF(ce)->key;
+			zend_string_addref(key);
 		}
 
 		zend_class_reference *ref = emalloc(ZEND_CLASS_REF_SIZE(parent_ce->num_generic_params));
 		ref->ce = parent_ce;
+		ref->key = key;
 		ref->args.num_types = parent_ce->num_generic_params;
 		generic_args -= ref->args.num_types;
 		memcpy(ref->args.types, generic_args, sizeof(zend_type) * ref->args.num_types);
@@ -1652,6 +1659,8 @@ static void update_parents(zend_class_entry *ce, zend_class_entry *parent_ce) {
 		} else {
 			zend_class_reference *new_ref = emalloc(ZEND_CLASS_REF_SIZE(ref->args.num_types));
 			new_ref->ce = ref->ce;
+			new_ref->key = ref->key;
+			zend_string_addref(new_ref->key);
 			new_ref->args.num_types = ref->args.num_types;
 			generic_args -= ref->args.num_types;
 			memcpy(new_ref->args.types, generic_args, sizeof(zend_type) * ref->args.num_types);
@@ -3048,11 +3057,14 @@ static void check_unrecoverable_load_failure(zend_class_entry *ce) {
 
 static zend_class_entry *zend_lazy_class_load(zend_class_entry *pce)
 {
+	zend_class_reference *class_ref;
 	zend_class_entry *ce;
 	Bucket *p, *end;
 
-	ce = zend_arena_alloc(&CG(arena), sizeof(zend_class_entry));
-	memcpy(ce, pce, sizeof(zend_class_entry));
+	class_ref = zend_arena_alloc(&CG(arena), sizeof(zend_class_entry_storage));
+	memcpy(class_ref, ZEND_CE_TO_REF(pce), sizeof(zend_class_entry_storage));
+	ce = (zend_class_entry*)((char*)class_ref + ZEND_CLASS_ENTRY_HEADER_SIZE);
+	class_ref->ce = ce;
 	ce->ce_flags &= ~ZEND_ACC_IMMUTABLE;
 	ce->refcount = 1;
 	ce->inheritance_cache = NULL;

Zend/zend_opcode.c

@@ -371,16 +371,6 @@ ZEND_API void destroy_zend_class(zval *zv)
 				if (ce->num_parents) {
 					if (!(ce->ce_flags & ZEND_ACC_RESOLVED_PARENT)) {
 						zend_pnr_release(ce->parent_name, /* uses_arena */ 1, /* persistent */ 0);
-					} else {
-						for (uint32_t i = 0; i < ce->num_parents; i++) {
-							zend_class_reference *ref = ce->parents[i];
-							if (!ZEND_REF_IS_TRIVIAL(ref)) {
-								/* The type arguments are owned by bound_generic_args,
-								 * and will be destroyed there. */
-								efree(ref);
-							}
-						}
-						efree(ce->parents);
 					}
 				}
 
@@ -427,6 +417,19 @@ ZEND_API void destroy_zend_class(zval *zv)
 				}
 			}
 
+			if (ce->num_parents && (ce->ce_flags & ZEND_ACC_RESOLVED_PARENT)) {
+				for (uint32_t i = 0; i < ce->num_parents; i++) {
+					zend_class_reference *ref = ce->parents[i];
+					if (!ZEND_REF_IS_TRIVIAL(ref)) {
+						/* The type arguments are owned by bound_generic_args,
+						 * and will be destroyed there. */
+						zend_string_release(ref->key);
+						efree(ref);
+					}
+				}
+				efree(ce->parents);
+			}
+
 			if (ce->default_properties_table) {
 				zval *p = ce->default_properties_table;
 				zval *end = p + ce->default_properties_count;