Fix non-persistent arg info

Using zend_convert_internal_arg_info_type() at runtime breaks
ZEND_RC_MOD_CHECK() assertions. Add a "persistent" param to make it possible to
convert an internal arg info to a non-persistent arg info.

Author: arnaud-lb

Zend/tests/unified_arg_infos_001.phpt

@@ -0,0 +1,21 @@
+--TEST--
+Declaring non persistent method with arg info
+--EXTENSIONS--
+zend_test
+--FILE--
+<?php
+
+$o = new _ZendTestClass();
+$o->testTmpMethodWithArgInfo(null);
+
+echo new ReflectionFunction($o->testTmpMethodWithArgInfo(...));
+
+?>
+--EXPECT--
+Closure [ <internal> public method testTmpMethodWithArgInfo ] {
+
+  - Parameters [2] {
+    Parameter #0 [ <optional> Foo|Bar|null $tmpMethodParamName = null ]
+    Parameter #1 [ <optional> string $tmpMethodParamWithStringDefaultValue = "tmpMethodParamWithStringDefaultValue" ]
+  }
+}

Zend/zend_API.c

@@ -2971,13 +2971,13 @@ static void zend_convert_internal_arg_info_type(zend_type *type, bool persistent
 
 		if (num_types == 1) {
 			/* Simple class type */
-			zend_string *str = zend_string_init_interned(class_name, strlen(class_name), true);
+			zend_string *str = zend_string_init_interned(class_name, strlen(class_name), persistent);
 			zend_alloc_ce_cache(str);
 			ZEND_TYPE_SET_PTR(*type, str);
 			type->type_mask |= _ZEND_TYPE_NAME_BIT;
 		} else {
 			/* Union type */
-			zend_type_list *list = pemalloc(ZEND_TYPE_LIST_SIZE(num_types), true);
+			zend_type_list *list = pemalloc(ZEND_TYPE_LIST_SIZE(num_types), persistent);
 			list->num_types = num_types;
 			ZEND_TYPE_SET_LIST(*type, list);
 			ZEND_TYPE_FULL_MASK(*type) |= _ZEND_TYPE_UNION_BIT;
@@ -2986,7 +2986,7 @@ static void zend_convert_internal_arg_info_type(zend_type *type, bool persistent
 			uint32_t j = 0;
 			while (true) {
 				const char *end = strchr(start, '|');
-				zend_string *str = zend_string_init_interned(start, end ? end - start : strlen(start), true);
+				zend_string *str = zend_string_init_interned(start, end ? end - start : strlen(start), persistent);
 				zend_alloc_ce_cache(str);
 				list->types[j] = (zend_type) ZEND_TYPE_INIT_CLASS(str, 0, 0);
 				if (!end) {
@@ -3010,12 +3010,12 @@ static void zend_convert_internal_arg_info_type(zend_type *type, bool persistent
 	}
 }
 
-ZEND_API void zend_convert_internal_arg_info(zend_arg_info *new_arg_info, const zend_internal_arg_info *arg_info, bool is_return_info)
+ZEND_API void zend_convert_internal_arg_info(zend_arg_info *new_arg_info, const zend_internal_arg_info *arg_info, bool is_return_info, bool persistent)
 {
 	if (!is_return_info) {
-		new_arg_info->name = zend_string_init_interned(arg_info->name, strlen(arg_info->name), true);
+		new_arg_info->name = zend_string_init_interned(arg_info->name, strlen(arg_info->name), persistent);
 		if (arg_info->default_value) {
-			new_arg_info->default_value = zend_string_init_interned(arg_info->default_value, strlen(arg_info->default_value), true);
+			new_arg_info->default_value = zend_string_init_interned(arg_info->default_value, strlen(arg_info->default_value), persistent);
 		} else {
 			new_arg_info->default_value = NULL;
 		}
@@ -3024,7 +3024,7 @@ ZEND_API void zend_convert_internal_arg_info(zend_arg_info *new_arg_info, const
 		new_arg_info->default_value = NULL;
 	}
 	new_arg_info->type = arg_info->type;
-	zend_convert_internal_arg_info_type(&new_arg_info->type);
+	zend_convert_internal_arg_info_type(&new_arg_info->type, persistent);
 }
 
 /* registers all functions in *library_functions in the function hash */
@@ -3236,7 +3236,8 @@ ZEND_API zend_result zend_register_functions(zend_class_entry *scope, const zend
 			new_arg_info = malloc(sizeof(zend_arg_info) * num_args);
 			reg_function->arg_info = new_arg_info + 1;
 			for (i = 0; i < num_args; i++) {
-				zend_convert_internal_arg_info(&new_arg_info[i], &arg_info[i], i == 0);
+				zend_convert_internal_arg_info(&new_arg_info[i], &arg_info[i],
+						i == 0, true);
 			}
 		}
 

Zend/zend_API.h

@@ -931,7 +931,8 @@ ZEND_API bool zend_is_iterable(const zval *iterable);
 ZEND_API bool zend_is_countable(const zval *countable);
 
 ZEND_API void zend_convert_internal_arg_info(zend_arg_info *new_arg_info,
-		const zend_internal_arg_info *arg_info, bool is_return_info);
+		const zend_internal_arg_info *arg_info, bool is_return_info,
+		bool permanent);
 
 ZEND_API zend_result zend_get_default_from_internal_arg_info(
 		zval *default_value_zval, const zend_arg_info *arg_info);

Zend/zend_enum.c

@@ -641,12 +641,12 @@ ZEND_API zend_object *zend_enum_get_case_cstr(zend_class_entry *ce, const char *
 void zend_enum_startup(void)
 {
 	for (size_t i = 0; i < sizeof(zarginfo_class_UnitEnum_cases)/sizeof(zend_arg_info); i++) {
-		zend_convert_internal_arg_info(&zarginfo_class_UnitEnum_cases[i], &arginfo_class_UnitEnum_cases[i], i == 0);
+		zend_convert_internal_arg_info(&zarginfo_class_UnitEnum_cases[i], &arginfo_class_UnitEnum_cases[i], i == 0, true);
 	}
 	for (size_t i = 0; i < sizeof(zarginfo_class_BackedEnum_from)/sizeof(zend_arg_info); i++) {
-		zend_convert_internal_arg_info(&zarginfo_class_BackedEnum_from[i], &arginfo_class_BackedEnum_from[i], i == 0);
+		zend_convert_internal_arg_info(&zarginfo_class_BackedEnum_from[i], &arginfo_class_BackedEnum_from[i], i == 0, true);
 	}
 	for (size_t i = 0; i < sizeof(zarginfo_class_BackedEnum_tryFrom)/sizeof(zend_arg_info); i++) {
-		zend_convert_internal_arg_info(&zarginfo_class_BackedEnum_tryFrom[i], &arginfo_class_BackedEnum_tryFrom[i], i == 0);
+		zend_convert_internal_arg_info(&zarginfo_class_BackedEnum_tryFrom[i], &arginfo_class_BackedEnum_tryFrom[i], i == 0, true);
 	}
 }

Zend/zend_opcode.c

@@ -123,8 +123,12 @@ ZEND_API void zend_type_release(zend_type type, bool persistent) {
 	}
 }
 
-ZEND_API void zend_free_internal_arg_info(zend_internal_function *function) {
+ZEND_API void zend_free_internal_arg_info(zend_internal_function *function,
+		bool persistent) {
 	if (function->arg_info) {
+		ZEND_ASSERT((persistent || (function->fn_flags & ZEND_ACC_NEVER_CACHE))
+				&& "Functions with non-persistent arg_info must be flagged ZEND_ACC_NEVER_CACHE");
+
 		uint32_t i;
 		uint32_t num_args = function->num_args + 1;
 		zend_arg_info *arg_info = function->arg_info - 1;
@@ -135,15 +139,16 @@ ZEND_API void zend_free_internal_arg_info(zend_internal_function *function) {
 		for (i = 0 ; i < num_args; i++) {
 			bool is_return_info = i == 0;
 			if (!is_return_info) {
-				zend_string_release_ex(arg_info[i].name, true);
+				zend_string_release_ex(arg_info[i].name, persistent);
 				if (arg_info[i].default_value) {
-					zend_string_release_ex(arg_info[i].default_value, true);
+					zend_string_release_ex(arg_info[i].default_value,
+							persistent);
 				}
 			}
-			zend_type_release(arg_info[i].type, /* persistent */ true);
+			zend_type_release(arg_info[i].type, persistent);
 		}
 
-		free(arg_info);
+		pefree(arg_info, persistent);
 	}
 }
 
@@ -162,7 +167,7 @@ ZEND_API void zend_function_dtor(zval *zv)
 
 		/* For methods this will be called explicitly. */
 		if (!function->common.scope) {
-			zend_free_internal_arg_info(&function->internal_function);
+			zend_free_internal_arg_info(&function->internal_function, true);
 
 			if (function->common.attributes) {
 				zend_hash_release(function->common.attributes);
@@ -481,7 +486,7 @@ ZEND_API void destroy_zend_class(zval *zv)
 
 			ZEND_HASH_MAP_FOREACH_PTR(&ce->function_table, fn) {
 				if (fn->common.scope == ce) {
-					zend_free_internal_arg_info(&fn->internal_function);
+					zend_free_internal_arg_info(&fn->internal_function, true);
 
 					if (fn->common.attributes) {
 						zend_hash_release(fn->common.attributes);

ext/pdo/pdo_dbh.c

@@ -1321,7 +1321,7 @@ static void cls_method_dtor(zval *el) /* {{{ */ {
 	if (func->common.attributes) {
 		zend_hash_release(func->common.attributes);
 	}
-	zend_free_internal_arg_info(&func->internal_function);
+	zend_free_internal_arg_info(&func->internal_function, false);
 	efree(func);
 }
 /* }}} */
@@ -1337,7 +1337,7 @@ static void cls_method_pdtor(zval *el) /* {{{ */ {
 	if (func->common.attributes) {
 		zend_hash_release(func->common.attributes);
 	}
-	zend_free_internal_arg_info(&func->internal_function);
+	zend_free_internal_arg_info(&func->internal_function, true);
 	pefree(func, 1);
 }
 /* }}} */
@@ -1415,9 +1415,11 @@ bool pdo_hash_methods(pdo_dbh_object_t *dbh_obj, int kind)
 				num_arg_info++;
 			}
 
-			zend_arg_info *arg_info = safe_pemalloc(num_arg_info, sizeof(zend_arg_info), 0, true);
+			zend_arg_info *arg_info = safe_pemalloc(num_arg_info,
+					sizeof(zend_arg_info), 0, dbh->is_persistent);
 			for (uint32_t i = 0; i < num_arg_info; i++) {
-				zend_convert_internal_arg_info(&arg_info[i], &funcs->arg_info[i], i == 0);
+				zend_convert_internal_arg_info(&arg_info[i],
+						&funcs->arg_info[i], i == 0, dbh->is_persistent);
 			}
 
 			func.arg_info = arg_info + 1;

ext/zend_test/test.c

@@ -37,10 +37,12 @@
 #include "Zend/Optimizer/zend_optimizer.h"
 #include "Zend/zend_alloc.h"
 #include "test_arginfo.h"
+#include "tmp_methods_arginfo.h"
 #include "zend_call_stack.h"
 #include "zend_exceptions.h"
 #include "zend_mm_custom_handlers.h"
 #include "ext/uri/php_uri.h"
+#include "zend_observer.h"
 
 #if defined(HAVE_LIBXML) && !defined(PHP_WIN32)
 # include <libxml/globals.h>
@@ -1023,16 +1025,38 @@ static ZEND_FUNCTION(zend_test_log_err_debug)
 	php_log_err_with_severity(ZSTR_VAL(str), LOG_DEBUG);
 }
 
+typedef struct _zend_test_object {
+	zend_internal_function *tmp_method;
+	zend_object std;
+} zend_test_object;
+
 static zend_object *zend_test_class_new(zend_class_entry *class_type)
 {
-	zend_object *obj = zend_objects_new(class_type);
-	object_properties_init(obj, class_type);
-	obj->handlers = &zend_test_class_handlers;
-	return obj;
+	zend_test_object *intern = zend_object_alloc(sizeof(zend_test_object), class_type);
+	zend_object_std_init(&intern->std, class_type);
+	object_properties_init(&intern->std, class_type);
+	return &intern->std;
+}
+
+static void zend_test_class_free_obj(zend_object *object)
+{
+	zend_test_object *intern = (zend_test_object*)((char*)object - XtOffsetOf(zend_test_object, std));
+
+	if (intern->tmp_method) {
+		zend_internal_function *func = intern->tmp_method;
+		intern->tmp_method = NULL;
+		zend_string_release_ex(func->function_name, 0);
+		zend_free_internal_arg_info(func, false);
+		efree(func);
+	}
+
+	zend_object_std_dtor(object);
 }
 
 static zend_function *zend_test_class_method_get(zend_object **object, zend_string *name, const zval *key)
 {
+	zend_test_object *intern = (zend_test_object*)((char*)(*object) - XtOffsetOf(zend_test_object, std));
+
 	if (zend_string_equals_literal_ci(name, "test")) {
 		zend_internal_function *fptr;
 
@@ -1050,6 +1074,41 @@ static zend_function *zend_test_class_method_get(zend_object **object, zend_stri
 		fptr->handler = ZEND_FN(zend_test_func);
 		fptr->doc_comment = NULL;
 
+		return (zend_function*)fptr;
+	} else if (zend_string_equals_literal_ci(name, "testTmpMethodWithArgInfo")) {
+		if (intern->tmp_method) {
+			return (zend_function*)intern->tmp_method;
+		}
+
+		const zend_function_entry *entry = &class_ZendTestTmpMethods_methods[0];
+		zend_internal_function *fptr = emalloc(sizeof(zend_internal_function));
+		memset(fptr, 0, sizeof(zend_internal_function));
+		fptr->type = ZEND_INTERNAL_FUNCTION;
+		fptr->handler = entry->handler;
+		fptr->function_name = zend_string_init(entry->fname, strlen(entry->fname), false);
+		fptr->scope = intern->std.ce;
+		fptr->prototype = NULL;
+		fptr->T = ZEND_OBSERVER_ENABLED;
+		fptr->fn_flags = ZEND_ACC_PUBLIC | ZEND_ACC_NEVER_CACHE;
+
+		zend_internal_function_info *info = (zend_internal_function_info*)entry->arg_info;
+
+		uint32_t num_arg_info = 1 + entry->num_args;
+		zend_arg_info *arg_info = safe_emalloc(num_arg_info, sizeof(zend_arg_info), 0);
+		for (uint32_t i = 0; i < num_arg_info; i++) {
+			zend_convert_internal_arg_info(&arg_info[i], &entry->arg_info[i], i == 0, false);
+		}
+
+		fptr->arg_info = arg_info + 1;
+		fptr->num_args = entry->num_args;
+		if (info->required_num_args == (uint32_t)-1) {
+			fptr->required_num_args = entry->num_args;
+		} else {
+			fptr->required_num_args = info->required_num_args;
+		}
+
+		intern->tmp_method = fptr;
+
 		return (zend_function*)fptr;
 	}
 	return zend_std_get_method(object, name, key);
@@ -1136,6 +1195,18 @@ static ZEND_METHOD(_ZendTestClass, variadicTest) {
 	object_init_ex(return_value, zend_get_called_scope(execute_data));
 }
 
+ZEND_METHOD(ZendTestTmpMethods, testTmpMethodWithArgInfo)
+{
+	zend_object *obj;
+	zend_string *str;
+
+	ZEND_PARSE_PARAMETERS_START(0, 2);
+		Z_PARAM_OPTIONAL;
+		Z_PARAM_OBJ_OR_NULL(obj);
+		Z_PARAM_STR(str);
+	ZEND_PARSE_PARAMETERS_END();
+}
+
 static ZEND_METHOD(_ZendTestChildClass, returnsThrowable)
 {
 	ZEND_PARSE_PARAMETERS_NONE();
@@ -1441,11 +1512,14 @@ PHP_MINIT_FUNCTION(zend_test)
 	register_ZendTestClass_dnf_property(zend_test_class);
 	zend_test_class->create_object = zend_test_class_new;
 	zend_test_class->get_static_method = zend_test_class_static_method_get;
+	zend_test_class->default_object_handlers = &zend_test_class_handlers;
 
 	zend_test_child_class = register_class__ZendTestChildClass(zend_test_class);
 
 	memcpy(&zend_test_class_handlers, &std_object_handlers, sizeof(zend_object_handlers));
 	zend_test_class_handlers.get_method = zend_test_class_method_get;
+	zend_test_class_handlers.free_obj = zend_test_class_free_obj;
+	zend_test_class_handlers.offset = XtOffsetOf(zend_test_object, std);
 
 	zend_test_gen_stub_flag_compatibility_test = register_class_ZendTestGenStubFlagCompatibilityTest();