zend_partial_create(): Remove the dependency on the declaring op_array

The declaring op_array is used for multiple purposes:
 * Generating a PFA name
 * Finding the filename
 * Finding whether op_array is cached, and therefore whether the PFA should be
   cached too

However it's not available when evaluating a PFA AST.

Remove the declaring_op_array argument, and pass the relevant information
directly:
 * Generate the filename at compile time, pass it as argument to zend_partial_create()
 * Pass the filename and a cacheable flag as argument to zend_partial_create()

Author: arnaud-lb

Zend/Optimizer/compact_literals.c

@@ -26,6 +26,7 @@
 #include "zend_execute.h"
 #include "zend_vm.h"
 #include "zend_extensions.h"
+#include "zend_partial.h"
 
 #define DEBUG_COMPACT_LITERALS 0
 
@@ -747,7 +748,7 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
 					}
 					break;
 				case ZEND_CALLABLE_CONVERT_PARTIAL:
-					opline->op1.num = cache_size;
+					opline->extended_value = cache_size | (opline->extended_value & ZEND_PARTIAL_FLAGS);
 					cache_size += 2 * sizeof(void *);
 					break;
 			}

Zend/tests/partial_application/pipe_optimization_004.phpt

@@ -37,7 +37,7 @@ $_main:
 0005 INIT_FCALL_BY_NAME 2 string("foo")
 0006 SEND_PLACEHOLDER 1
 0007 SEND_PLACEHOLDER 2
-0008 T1 = CALLABLE_CONVERT_PARTIAL %d
+0008 T1 = CALLABLE_CONVERT_PARTIAL %d string("{closure:%s}")
 0009 INIT_DYNAMIC_CALL 1 T1
 0010 SEND_VAL_EX int(2) 1
 0011 DO_FCALL

Zend/tests/partial_application/pipe_optimization_007.phpt

@@ -37,7 +37,7 @@ $_main:
 0005 INIT_FCALL_BY_NAME 0 string("foo")
 0006 SEND_PLACEHOLDER string("a")
 0007 SEND_PLACEHOLDER string("b")
-0008 T1 = CALLABLE_CONVERT_PARTIAL %d array(...)
+0008 T1 = CALLABLE_CONVERT_PARTIAL %d string("{closure:%s}") array(...)
 0009 INIT_DYNAMIC_CALL 1 T1
 0010 SEND_VAL_EX int(2) 1
 0011 DO_FCALL

Zend/tests/partial_application/pipe_optimization_008.phpt

@@ -36,7 +36,7 @@ $_main:
 0004 DECLARE_FUNCTION string("foo") 0
 0005 INIT_FCALL_BY_NAME 0 string("foo")
 0006 SEND_VAL_EX int(1) string("a")
-0007 T1 = CALLABLE_CONVERT_PARTIAL %d
+0007 T1 = CALLABLE_CONVERT_PARTIAL %d string("{closure:%s}")
 0008 INIT_DYNAMIC_CALL 1 T1
 0009 SEND_VAL_EX int(2) 1
 0010 DO_FCALL

Zend/tests/partial_application/pipe_optimization_013.phpt

@@ -32,7 +32,7 @@ $_main:
 0004 DECLARE_FUNCTION string("foo") 0
 0005 INIT_FCALL_BY_NAME 0 string("foo")
 0006 SEND_VAL_EX int(2) string("b")
-0007 T0 = CALLABLE_CONVERT_PARTIAL 3
+0007 T0 = CALLABLE_CONVERT_PARTIAL %d string("{closure:%s}")
 0008 INIT_DYNAMIC_CALL 1 T0
 0009 SEND_VAL_EX int(1) 1
 0010 DO_FCALL

Zend/zend_ast.c

@@ -60,6 +60,8 @@ ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_fcc(zend_ast *args) {
 	ast->kind = ZEND_AST_CALLABLE_CONVERT;
 	ast->attr = 0;
 	ast->lineno = CG(zend_lineno);
+	ast->filename = NULL;
+	ast->name = NULL;
 	ast->args = args;
 	ZEND_MAP_PTR_INIT(ast->fptr, NULL);
 
@@ -1425,6 +1427,16 @@ static void* ZEND_FASTCALL zend_ast_tree_copy(zend_ast *ast, void *buf)
 		new->kind = old->kind;
 		new->attr = old->attr;
 		new->lineno = old->lineno;
+		if (old->filename) {
+			new->filename = zend_string_copy(old->filename);
+		} else {
+			new->filename = NULL;
+		}
+		if (old->name) {
+			new->name = zend_string_copy(old->name);
+		} else {
+			new->name = NULL;
+		}
 		ZEND_MAP_PTR_INIT(new->fptr, ZEND_MAP_PTR(old->fptr));
 		buf = (void*)((char*)buf + sizeof(zend_ast_fcc));
 		new->args = buf;
@@ -1525,6 +1537,12 @@ ZEND_API void ZEND_FASTCALL zend_ast_destroy(zend_ast *ast)
 	} else if (EXPECTED(ast->kind == ZEND_AST_CALLABLE_CONVERT)) {
 		zend_ast_fcc *fcc_ast = (zend_ast_fcc*) ast;
 
+		if (fcc_ast->filename) {
+			zend_string_release_ex(fcc_ast->filename, 0);
+		}
+		if (fcc_ast->name) {
+			zend_string_release_ex(fcc_ast->name, 0);
+		}
 		ast = fcc_ast->args;
 		goto tail_call;
 	}

Zend/zend_ast.h

@@ -233,6 +233,8 @@ typedef struct _zend_ast_fcc {
 	zend_ast_kind kind; /* Type of the node (ZEND_AST_* enum constant) */
 	zend_ast_attr attr; /* Additional attribute, use depending on node type */
 	uint32_t lineno;    /* Line number */
+	zend_string *filename;
+	zend_string *name;
 	zend_ast *args;
 	ZEND_MAP_PTR_DEF(zend_function *, fptr);
 } zend_ast_fcc;

Zend/zend_compile.c

@@ -40,6 +40,7 @@
 #include "zend_call_stack.h"
 #include "zend_frameless_function.h"
 #include "zend_property_hooks.h"
+#include "zend_partial.h"
 
 #define SET_NODE(target, src) do { \
 		target ## _type = (src)->op_type; \
@@ -4088,7 +4089,50 @@ ZEND_API uint8_t zend_get_call_op(const zend_op *init_op, const zend_function *f
 }
 /* }}} */
 
-static void zend_compile_call_partial(znode *result, uint32_t arg_count,
+static zend_string *zend_compile_partial_name(const zend_op_array *declaring_op_array,
+		const uint32_t declaring_lineno)
+{
+	/* We attempt to generate a name that hints at where the PFA was created,
+	 * similarly to Closures (GH-13550).
+	 * We do not attempt to make the name unique. */
+
+	zend_string *filename = declaring_op_array->filename;
+	uint32_t start_lineno = declaring_lineno;
+
+	zend_string *class = zend_empty_string;
+	zend_string *separator = zend_empty_string;
+	zend_string *function = filename;
+	const char *parens = "";
+
+	if (declaring_op_array->function_name) {
+		function = declaring_op_array->function_name;
+		if (declaring_op_array->fn_flags & ZEND_ACC_CLOSURE) {
+			/* If the parent function is a closure, don't redundantly
+			 * add the classname and parentheses. */
+		} else {
+			parens = "()";
+
+			if (declaring_op_array->scope && declaring_op_array->scope->name) {
+				class = declaring_op_array->scope->name;
+				separator = ZSTR_KNOWN(ZEND_STR_PAAMAYIM_NEKUDOTAYIM);
+			}
+		}
+	}
+
+	zend_string *name = zend_strpprintf_unchecked(
+		0,
+		"{closure:pfa:%S%S%S%s:%" PRIu32 "}",
+		class,
+		separator,
+		function,
+		parens,
+		start_lineno
+	);
+
+	return name;
+}
+
+static void zend_compile_call_partial(znode *result, zend_ast_fcc *fcc_ast, uint32_t arg_count,
 		bool may_have_extra_named_args, bool uses_variadic_placeholder,
 		zval *named_positions, uint32_t opnum_init, const zend_function *fbc) {
 
@@ -4105,15 +4149,16 @@ static void zend_compile_call_partial(znode *result, uint32_t arg_count,
 	zend_op *opline = zend_emit_op_tmp(result, ZEND_CALLABLE_CONVERT_PARTIAL,
 				NULL, NULL);
 
-	opline->op1.num = zend_alloc_cache_slots(2);
+	opline->extended_value = zend_alloc_cache_slots(2);
 
-	if (may_have_extra_named_args) {
-		opline->extended_value = ZEND_FCALL_MAY_HAVE_EXTRA_NAMED_PARAMS;
-	}
 	if (uses_variadic_placeholder) {
-		opline->extended_value |= ZEND_FCALL_USES_VARIADIC_PLACEHOLDER;
+		opline->extended_value |= ZEND_PARTIAL_USES_VARIADIC_PLACEHOLDER;
 	}
 
+	zend_string *name = zend_compile_partial_name(CG(active_op_array), opline->lineno);
+	opline->op1.constant = zend_add_literal_string(&name);
+	opline->op1_type = IS_CONST;
+
 	if (!Z_ISUNDEF_P(named_positions)) {
 		opline->op2.constant = zend_add_literal(named_positions);
 		opline->op2_type = IS_CONST;
@@ -4156,7 +4201,8 @@ static bool zend_compile_call_common(znode *result, zend_ast *args_ast, const ze
 			return true;
 		}
 
-		args_ast = ((zend_ast_fcc*)args_ast)->args;
+		zend_ast_fcc *fcc_ast = (zend_ast_fcc*)args_ast;
+		args_ast = fcc_ast->args;
 
 		bool may_have_extra_named_args;
 		bool uses_variadic_placeholder;
@@ -4168,7 +4214,7 @@ static bool zend_compile_call_common(znode *result, zend_ast *args_ast, const ze
 				&may_have_extra_named_args, true, &uses_variadic_placeholder,
 				&named_positions);
 
-		zend_compile_call_partial(result, arg_count,
+		zend_compile_call_partial(result, fcc_ast, arg_count,
 				may_have_extra_named_args, uses_variadic_placeholder,
 				&named_positions, opnum_init, fbc);
 
@@ -12021,10 +12067,14 @@ static void zend_compile_const_expr_fcc(zend_ast **ast_ptr)
 		zend_error_noreturn(E_COMPILE_ERROR, "Constant expression contains invalid operations");
 	}
 
-	zend_ast_list *args = zend_ast_get_list(((zend_ast_fcc*)*args_ast)->args);
-	if (args->children != 1 || args->child[0]->attr != ZEND_PLACEHOLDER_VARIADIC) {
-		// TODO: PFAs
-		zend_error_noreturn(E_COMPILE_ERROR, "Constant expression contains invalid operations");
+	zend_ast_fcc *fcc = (zend_ast_fcc*)args_ast;
+
+	zend_ast_list *args = zend_ast_get_list(fcc->args);
+	bool is_fcc = args->children == 1 && args->child[0]->attr == ZEND_PLACEHOLDER_VARIADIC;
+
+	if (!is_fcc) {
+		fcc->filename = zend_string_copy(CG(active_op_array)->filename);
+		fcc->name = zend_compile_partial_name(CG(active_op_array), fcc->lineno);
 	}
 
 	switch ((*ast_ptr)->kind) {

Zend/zend_compile.h

@@ -1121,7 +1121,6 @@ ZEND_API zend_string *zend_type_to_string(zend_type type);
 #define ZEND_THROW_IS_EXPR 1u
 
 #define ZEND_FCALL_MAY_HAVE_EXTRA_NAMED_PARAMS (1<<0)
-#define ZEND_FCALL_USES_VARIADIC_PLACEHOLDER   (1<<1)
 
 /* The send mode, the is_variadic, the is_promoted, and the is_tentative flags are stored as part of zend_type */
 #define _ZEND_SEND_MODE_SHIFT _ZEND_TYPE_EXTRA_FLAGS_SHIFT

Zend/zend_partial.c

@@ -51,6 +51,7 @@
 #include "zend_closures.h"
 #include "zend_attributes.h"
 #include "zend_exceptions.h"
+#include "zend_partial.h"
 #include "ext/opcache/ZendAccelerator.h"
 
 static zend_always_inline bool Z_IS_PLACEHOLDER_P(const zval *p) {
@@ -502,49 +503,6 @@ static zend_ast *zp_param_attributes_to_ast(zend_function *function,
 	return attributes_ast;
 }
 
-static zend_string *zp_pfa_name(const zend_op_array *declaring_op_array,
-		const uint32_t *declaring_lineno_ptr)
-{
-	/* We attempt to generate a name that hints at where the PFA was created,
-	 * similarly to Closures (GH-13550).
-	 * We do not attempt to make the name unique. */
-
-	zend_string *filename = declaring_op_array->filename;
-	uint32_t start_lineno = *declaring_lineno_ptr;
-
-	zend_string *class = zend_empty_string;
-	zend_string *separator = zend_empty_string;
-	zend_string *function = filename;
-	const char *parens = "";
-
-	if (declaring_op_array->function_name) {
-		function = declaring_op_array->function_name;
-		if (declaring_op_array->fn_flags & ZEND_ACC_CLOSURE) {
-			/* If the parent function is a closure, don't redundantly
-			 * add the classname and parentheses. */
-		} else {
-			parens = "()";
-
-			if (declaring_op_array->scope && declaring_op_array->scope->name) {
-				class = declaring_op_array->scope->name;
-				separator = ZSTR_KNOWN(ZEND_STR_PAAMAYIM_NEKUDOTAYIM);
-			}
-		}
-	}
-
-	zend_string *name = zend_strpprintf_unchecked(
-		0,
-		"{closure:pfa:%S%S%S%s:%" PRIu32 "}",
-		class,
-		separator,
-		function,
-		parens,
-		start_lineno
-	);
-
-	return name;
-}
-
 /* Generate the AST for calling the actual function */
 static zend_ast *zp_compile_forwarding_call(
 	zval *this_ptr, zend_function *function,
@@ -700,9 +658,9 @@ static uint32_t zp_compute_num_required(const zend_function *function,
 static zend_op_array *zp_compile(zval *this_ptr, zend_function *function,
 		uint32_t argc, zval *argv, zend_array *extra_named_params,
 		const zend_array *named_positions,
-		const zend_op_array *declaring_op_array,
+		zend_string *declaring_filename,
 		const uint32_t *declaring_lineno_ptr, void **cache_slot,
-		bool uses_variadic_placeholder) {
+		zend_string *pfa_name, uint32_t flags) {
 
 	zend_op_array *op_array = NULL;
 
@@ -712,6 +670,8 @@ static zend_op_array *zp_compile(zval *this_ptr, zend_function *function,
 		return NULL;
 	}
 
+	bool uses_variadic_placeholder = flags & ZEND_PARTIAL_USES_VARIADIC_PLACEHOLDER;
+
 	if (UNEXPECTED(zp_args_check(function, argc, argv, extra_named_params, uses_variadic_placeholder) != SUCCESS)) {
 		ZEND_ASSERT(EG(exception));
 		return NULL;
@@ -1011,10 +971,8 @@ static zend_op_array *zp_compile(zval *this_ptr, zend_function *function,
 	}
 #endif
 
-	zend_string *pfa_name = zp_pfa_name(declaring_op_array, declaring_lineno_ptr);
-
-	op_array = zend_accel_compile_pfa(closure_ast, declaring_op_array,
-			declaring_lineno_ptr, function, pfa_name);
+	op_array = zend_accel_compile_pfa(closure_ast, declaring_filename,
+			declaring_lineno_ptr, function, pfa_name, flags & ZEND_PARTIAL_CACHEABLE_IN_SHM);
 
 	zend_ast_destroy(closure_ast);
 
@@ -1039,9 +997,9 @@ static zend_op_array *zp_compile(zval *this_ptr, zend_function *function,
 static const zend_op_array *zp_get_op_array(zval *this_ptr, zend_function *function,
 		uint32_t argc, zval *argv, zend_array *extra_named_params,
 		const zend_array *named_positions,
-		const zend_op_array *declaring_op_array,
+		zend_string *declaring_filename,
 		const uint32_t *declaring_lineno_ptr, void **cache_slot,
-		bool uses_variadic_placeholder) {
+		zend_string *pfa_name, uint32_t flags) {
 
 	if (EXPECTED(function->type == ZEND_INTERNAL_FUNCTION
 					? cache_slot[0] == function
@@ -1050,13 +1008,13 @@ static const zend_op_array *zp_get_op_array(zval *this_ptr, zend_function *funct
 		return cache_slot[1];
 	}
 
-	const zend_op_array *op_array = zend_accel_pfa_cache_get(declaring_op_array,
-			declaring_lineno_ptr, function);
+	const zend_op_array *op_array = zend_accel_pfa_cache_get(declaring_lineno_ptr, function,
+			flags & ZEND_PARTIAL_CACHEABLE_IN_SHM);
 
 	if (UNEXPECTED(!op_array)) {
 		op_array = zp_compile(this_ptr, function, argc, argv,
-			extra_named_params, named_positions, declaring_op_array, declaring_lineno_ptr,
-			cache_slot, uses_variadic_placeholder);
+			extra_named_params, named_positions, declaring_filename, declaring_lineno_ptr,
+			cache_slot, pfa_name, flags);
 	}
 
 	if (EXPECTED(op_array) && !(function->common.fn_flags & ZEND_ACC_NEVER_CACHE)) {
@@ -1120,14 +1078,16 @@ static void zp_bind(zval *result, zend_function *function, uint32_t argc, zval *
 void zend_partial_create(zval *result, zval *this_ptr, zend_function *function,
 		uint32_t argc, zval *argv, zend_array *extra_named_params,
 		const zend_array *named_positions,
-		const zend_op_array *declaring_op_array,
+		zend_string *declaring_filename,
 		const uint32_t *declaring_lineno_ptr, void **cache_slot,
-		bool uses_variadic_placeholder) {
+		zend_string *pfa_name, uint32_t flags) {
+
+	ZEND_ASSERT(pfa_name);
 
 	const zend_op_array *op_array = zp_get_op_array(this_ptr, function, argc, argv,
 			extra_named_params, named_positions,
-			declaring_op_array, declaring_lineno_ptr,
-			cache_slot, uses_variadic_placeholder);
+			declaring_filename, declaring_lineno_ptr,
+			cache_slot, pfa_name, flags);
 
 	if (UNEXPECTED(!op_array)) {
 		ZEND_ASSERT(EG(exception));