Store the declaring op_array in FCC/PFA const exprs AST

This will be useful when compiling the PFA, as zend_partial_create() needs it.

Author: arnaud-lb

Zend/zend_ast.c

@@ -60,6 +60,7 @@ 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->declaring_op_array = NULL;
 	ast->args = args;
 	ZEND_MAP_PTR_INIT(ast->fptr, NULL);
 
@@ -1425,6 +1426,7 @@ 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;
+		new->declaring_op_array = old->declaring_op_array;
 		ZEND_MAP_PTR_INIT(new->fptr, ZEND_MAP_PTR(old->fptr));
 		buf = (void*)((char*)buf + sizeof(zend_ast_fcc));
 		new->args = buf;

Zend/zend_ast.h

@@ -233,6 +233,7 @@ 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_op_array *declaring_op_array;
 	zend_ast *args;
 	ZEND_MAP_PTR_DEF(zend_function *, fptr);
 } zend_ast_fcc;

Zend/zend_compile.c

@@ -12021,11 +12021,8 @@ 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;
+	fcc->declaring_op_array = CG(active_op_array);
 
 	switch ((*ast_ptr)->kind) {
 		case ZEND_AST_CALL: {

ext/opcache/ZendAccelerator.h

@@ -222,6 +222,7 @@ typedef struct _zend_accel_globals {
 	/* preallocated shared-memory block to save current script */
 	void                   *mem;
 	zend_persistent_script *current_persistent_script;
+	zend_op_array          *current_persistent_op_array;
 	/* cache to save hash lookup on the same INCLUDE opcode */
 	const zend_op          *cache_opline;
 	zend_persistent_script *cache_persistent_script;

ext/opcache/zend_file_cache.c

@@ -1308,6 +1308,7 @@ static void zend_file_cache_unserialize_ast(zend_ast                *ast,
 		zend_ast_get_op_array(ast)->op_array = Z_PTR(z);
 	} else if (ast->kind == ZEND_AST_CALLABLE_CONVERT) {
 		zend_ast_fcc *fcc = (zend_ast_fcc*)ast;
+		fcc->declaring_op_array = CG(active_op_array);
 		ZEND_MAP_PTR_NEW(fcc->fptr);
 		if (!IS_UNSERIALIZED(fcc->args)) {
 			UNSERIALIZE_PTR(fcc->args);
@@ -1414,6 +1415,9 @@ static void zend_file_cache_unserialize_op_array(zend_op_array           *op_arr
                                                  zend_persistent_script  *script,
                                                  void                    *buf)
 {
+	zend_op_array *orig_op_array = CG(active_op_array);
+	CG(active_op_array) = op_array;
+
 	if (!script->corrupted) {
 		if (op_array != &script->script.main_op_array) {
 			op_array->fn_flags |= ZEND_ACC_IMMUTABLE;
@@ -1434,7 +1438,7 @@ static void zend_file_cache_unserialize_op_array(zend_op_array           *op_arr
 	/* Check whether this op_array has already been unserialized. */
 	if (IS_UNSERIALIZED(op_array->opcodes)) {
 		ZEND_ASSERT(op_array->scope && "Only method op_arrays should be shared");
-		return;
+		goto end;
 	}
 
 	if (op_array->refcount) {
@@ -1453,7 +1457,7 @@ static void zend_file_cache_unserialize_op_array(zend_op_array           *op_arr
 		UNSERIALIZE_PTR(op_array->try_catch_array);
 		UNSERIALIZE_PTR(op_array->prototype);
 		UNSERIALIZE_PTR(op_array->prop_info);
-		return;
+		goto end;
 	}
 
 	if (op_array->static_variables) {
@@ -1597,6 +1601,9 @@ static void zend_file_cache_unserialize_op_array(zend_op_array           *op_arr
 		UNSERIALIZE_PTR(op_array->prototype);
 		UNSERIALIZE_PTR(op_array->prop_info);
 	}
+
+end:
+	CG(active_op_array) = orig_op_array;
 }
 
 static void zend_file_cache_unserialize_func(zval                    *zv,
@@ -1888,6 +1895,9 @@ static void zend_file_cache_unserialize(zend_persistent_script  *script,
 {
 	script->mem = buf;
 
+	zend_op_array *orig_op_array = CG(active_op_array);
+	CG(active_op_array) = &script->script.main_op_array;
+
 	UNSERIALIZE_STR(script->script.filename);
 
 	zend_file_cache_unserialize_hash(&script->script.class_table,
@@ -1897,6 +1907,8 @@ static void zend_file_cache_unserialize(zend_persistent_script  *script,
 	zend_file_cache_unserialize_op_array(&script->script.main_op_array, script, buf);
 	zend_file_cache_unserialize_warnings(script, buf);
 	zend_file_cache_unserialize_early_bindings(script, buf);
+
+	CG(active_op_array) = orig_op_array;
 }
 
 static zend_persistent_script file_cache_validate_success_script;

ext/opcache/zend_persist.c

@@ -195,6 +195,8 @@ static zend_ast *zend_persist_ast(zend_ast *ast)
 		node = (zend_ast *) copy;
 	} else if (ast->kind == ZEND_AST_CALLABLE_CONVERT) {
 		zend_ast_fcc *copy = zend_shared_memdup(ast, sizeof(zend_ast_fcc));
+		ZEND_ASSERT(ZCG(current_persistent_op_array));
+		copy->declaring_op_array = ZCG(current_persistent_op_array);
 		copy->args = zend_persist_ast(copy->args);
 		ZEND_MAP_PTR_NEW(copy->fptr);
 		node = (zend_ast *) copy;
@@ -393,6 +395,9 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc
 	zend_op *persist_ptr;
 	zval *orig_literals = NULL;
 
+	zend_op_array *orig_persistent_op_array = ZCG(current_persistent_op_array);
+	ZCG(current_persistent_op_array) = op_array;
+
 	if (op_array->refcount && --(*op_array->refcount) == 0) {
 		efree(op_array->refcount);
 	}
@@ -494,7 +499,7 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc
 				ZEND_ASSERT(op_array->dynamic_func_defs != NULL);
 			}
 			ZCG(mem) = (void*)((char*)ZCG(mem) + ZEND_ALIGNED_SIZE(zend_extensions_op_array_persist(op_array, ZCG(mem))));
-			return;
+			goto end;
 		}
 	} else {
 		/* "prototype" may be undefined if "scope" isn't set */
@@ -504,7 +509,7 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc
 	if (op_array->scope
 	 && !(op_array->fn_flags & ZEND_ACC_CLOSURE)
 	 && (op_array->scope->ce_flags & ZEND_ACC_CACHED)) {
-		return;
+		goto end;
 	}
 
 	if (op_array->static_variables && !zend_accel_in_shm(op_array->static_variables)) {
@@ -701,6 +706,8 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc
 	}
 
 	ZCG(mem) = (void*)((char*)ZCG(mem) + ZEND_ALIGNED_SIZE(zend_extensions_op_array_persist(op_array, ZCG(mem))));
+end:
+	ZCG(current_persistent_op_array) = orig_persistent_op_array;
 }
 
 static void zend_persist_op_array(zval *zv)
@@ -1433,6 +1440,7 @@ zend_persistent_script *zend_accel_script_persist(zend_persistent_script *script
 	script = zend_shared_memdup_free(script, sizeof(zend_persistent_script));
 	script->corrupted = false;
 	ZCG(current_persistent_script) = script;
+	ZCG(current_persistent_op_array) = &script->script.main_op_array;
 
 	if (!for_shm) {
 		/* script is not going to be saved in SHM */
@@ -1495,6 +1503,7 @@ zend_persistent_script *zend_accel_script_persist(zend_persistent_script *script
 
 	script->corrupted = false;
 	ZCG(current_persistent_script) = NULL;
+	ZCG(current_persistent_op_array) = NULL;
 
 	return script;
 }