diff --git a/Zend/Optimizer/zend_dump.c b/Zend/Optimizer/zend_dump.c index 4e46b38a8eb5e..b171eaebd1890 100644 --- a/Zend/Optimizer/zend_dump.c +++ b/Zend/Optimizer/zend_dump.c @@ -479,7 +479,10 @@ ZEND_API void zend_dump_op(const zend_op_array *op_array, const zend_basic_block if (ZEND_OP_IS_FRAMELESS_ICALL(opline->opcode)) { zend_function *func = ZEND_FLF_FUNC(opline); - fprintf(stderr, "(%s)", ZSTR_VAL(func->common.function_name)); + fprintf(stderr, "(%s%s%s)", + func->common.scope ? ZSTR_VAL(func->common.scope->name) : "", + func->common.scope ? "::" : "", + ZSTR_VAL(func->common.function_name)); } if (ZEND_VM_EXT_NUM == (flags & ZEND_VM_EXT_MASK)) { diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index e33990c73bb67..7eadef4644c41 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -5336,28 +5336,11 @@ static void zend_compile_static_call(znode *result, zend_ast *ast, uint32_t type } } - opline = get_next_op(); - opline->opcode = ZEND_INIT_STATIC_METHOD_CALL; - - zend_set_class_name_op1(opline, &class_node); - - if (method_node.op_type == IS_CONST) { - opline->op2_type = IS_CONST; - opline->op2.constant = zend_add_func_name_literal( - Z_STR(method_node.u.constant)); - opline->result.num = zend_alloc_cache_slots(2); - } else { - if (opline->op1_type == IS_CONST) { - opline->result.num = zend_alloc_cache_slot(); - } - SET_NODE(opline->op2, &method_node); - } - /* Check if we already know which method we're calling */ - if (opline->op2_type == IS_CONST) { + if (method_node.op_type == IS_CONST) { zend_class_entry *ce = NULL; - if (opline->op1_type == IS_CONST) { - zend_string *lcname = Z_STR_P(CT_CONSTANT(opline->op1) + 1); + if (class_node.op_type == IS_CONST) { + zend_string *lcname = zend_string_tolower(Z_STR(class_node.u.constant)); ce = zend_hash_find_ptr(CG(class_table), lcname); if (ce) { if (zend_compile_ignore_class(ce, CG(active_op_array)->filename)) { @@ -5367,15 +5350,48 @@ static void zend_compile_static_call(znode *result, zend_ast *ast, uint32_t type && zend_string_equals_ci(CG(active_class_entry)->name, lcname)) { ce = CG(active_class_entry); } - } else if (opline->op1_type == IS_UNUSED - && (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF + zend_string_release(lcname); + } else if (class_node.op_type == IS_UNUSED + && (class_node.u.op.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF && zend_is_scope_known()) { ce = CG(active_class_entry); } if (ce) { - zend_string *lcname = Z_STR_P(CT_CONSTANT(opline->op2) + 1); + zend_string *lcname = zend_string_tolower(Z_STR(method_node.u.constant)); fbc = zend_get_compatible_func_or_null(ce, lcname); + zend_string_release(lcname); + + if (fbc + && !(CG(compiler_options) & ZEND_COMPILE_NO_BUILTINS) + && (fbc->type == ZEND_INTERNAL_FUNCTION) + && zend_ast_is_list(args_ast) + && !zend_args_contain_unpack_or_named(zend_ast_get_list(args_ast))) { + if (zend_compile_frameless_icall(result, zend_ast_get_list(args_ast), fbc, type) != (uint32_t)-1) { + zval_ptr_dtor(&method_node.u.constant); + if (class_node.op_type == IS_CONST) { + zval_ptr_dtor(&class_node.u.constant); + } + return; + } + } + } + } + + opline = get_next_op(); + opline->opcode = ZEND_INIT_STATIC_METHOD_CALL; + + zend_set_class_name_op1(opline, &class_node); + + if (method_node.op_type == IS_CONST) { + opline->op2_type = IS_CONST; + opline->op2.constant = zend_add_func_name_literal( + Z_STR(method_node.u.constant)); + opline->result.num = zend_alloc_cache_slots(2); + } else { + if (opline->op1_type == IS_CONST) { + opline->result.num = zend_alloc_cache_slot(); } + SET_NODE(opline->op2, &method_node); } zend_compile_call_common(result, args_ast, fbc, zend_ast_get_lineno(method_ast)); diff --git a/build/gen_stub.php b/build/gen_stub.php index f8e16064ee292..d4eff6a16ae57 100755 --- a/build/gen_stub.php +++ b/build/gen_stub.php @@ -1060,6 +1060,10 @@ public function getDeclarationClassName(): string { return implode('_', $this->className->getParts()); } + public function getDeclarationName(): string { + return "{$this->getDeclarationClassName()}_{$this->methodName}"; + } + public function getDeclaration(): string { return "ZEND_METHOD({$this->getDeclarationClassName()}, $this->methodName);\n"; } @@ -1068,6 +1072,10 @@ public function getArgInfoName(): string { return "arginfo_class_{$this->getDeclarationClassName()}_{$this->methodName}"; } + public function getFramelessFunctionInfosName(): string { + return "frameless_function_infos_{$this->className}_{$this->methodName}"; + } + public function getMethodSynopsisFilename(): string { $parts = [...$this->className->getParts(), ltrim($this->methodName, '_')]; @@ -1331,12 +1339,12 @@ public function getFramelessDeclaration(): ?string { } foreach ($this->framelessFunctionInfos as $framelessFunctionInfo) { - $code .= "ZEND_FRAMELESS_FUNCTION({$this->name->getFunctionName()}, {$framelessFunctionInfo->arity});\n"; + $code .= "ZEND_FRAMELESS_FUNCTION({$this->name->getDeclarationName()}, {$framelessFunctionInfo->arity});\n"; } $code .= 'static const zend_frameless_function_info ' . $this->getFramelessFunctionInfosName() . "[] = {\n"; foreach ($this->framelessFunctionInfos as $framelessFunctionInfo) { - $code .= "\t{ ZEND_FRAMELESS_FUNCTION_NAME({$this->name->getFunctionName()}, {$framelessFunctionInfo->arity}), {$framelessFunctionInfo->arity} },\n"; + $code .= "\t{ ZEND_FRAMELESS_FUNCTION_NAME({$this->name->getDeclarationName()}, {$framelessFunctionInfo->arity}), {$framelessFunctionInfo->arity} },\n"; } $code .= "\t{ 0 },\n"; $code .= "};\n"; @@ -1362,10 +1370,10 @@ public function getFunctionEntry(): string { $functionEntryCode = null; if (!empty($this->framelessFunctionInfos)) { - if ($this->isMethod()) { - throw new Exception('Frameless methods are not supported yet'); + if ($this->isMethod() && !($this->flags & Modifiers::STATIC)) { + throw new Exception('Frameless methods must be static'); } - if ($this->name->getNamespace()) { + if (!$this->isMethod() && $this->name->getNamespace()) { throw new Exception('Namespaced direct calls to frameless functions are not supported yet'); } if ($this->alias) { diff --git a/ext/zend_test/test.c b/ext/zend_test/test.c index e3f87ee1e1636..55d86896468e8 100644 --- a/ext/zend_test/test.c +++ b/ext/zend_test/test.c @@ -1169,6 +1169,30 @@ static ZEND_METHOD(_ZendTestClass, takesUnionType) RETURN_NULL(); } +static ZEND_METHOD(_ZendTestClass, framelessStaticMethod) +{ + zend_long lhs, rhs; + + ZEND_PARSE_PARAMETERS_START(2, 2) + Z_PARAM_LONG(lhs) + Z_PARAM_LONG(rhs) + ZEND_PARSE_PARAMETERS_END(); + + RETURN_LONG(lhs + rhs); +} + +ZEND_FRAMELESS_FUNCTION(_ZendTestClass_framelessStaticMethod, 2) +{ + zend_long lhs, rhs; + + Z_FLF_PARAM_LONG(1, lhs); + Z_FLF_PARAM_LONG(2, rhs); + + ZVAL_LONG(return_value, lhs + rhs); + +flf_clean:; +} + // Returns a newly allocated DNF type `Iterator|(Traversable&Countable)`. // // We need to generate it "manually" because gen_stubs.php does not support codegen for DNF types ATM. diff --git a/ext/zend_test/test.stub.php b/ext/zend_test/test.stub.php index 59cb9661e4e43..bddffaa1accc5 100644 --- a/ext/zend_test/test.stub.php +++ b/ext/zend_test/test.stub.php @@ -69,6 +69,9 @@ public function returnsThrowable(): Throwable {} static public function variadicTest(string|Iterator ...$elements) : static {} public function takesUnionType(stdclass|Iterator $arg): void {} + + /** @frameless-function {"arity": 2} */ + public static function framelessStaticMethod(int $lhs, int $rhs): int {} } class _ZendTestMagicCall diff --git a/ext/zend_test/test_arginfo.h b/ext/zend_test/test_arginfo.h index c558b58f65169..94e602a155810 100644 --- a/ext/zend_test/test_arginfo.h +++ b/ext/zend_test/test_arginfo.h @@ -1,5 +1,5 @@ /* This is a generated file, edit the .stub.php file instead. - * Stub hash: 3082e62e96d5f4383c98638513463c676a7c3a69 */ + * Stub hash: 5ea0e1aae76e9f10b6e5c17d4d55f51e353ebbf2 */ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zend_test_array_return, 0, 0, IS_ARRAY, 0) ZEND_END_ARG_INFO() @@ -203,6 +203,11 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class__ZendTestClass_takesUnionT ZEND_ARG_OBJ_TYPE_MASK(0, arg, stdclass|Iterator, 0, NULL) ZEND_END_ARG_INFO() +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class__ZendTestClass_framelessStaticMethod, 0, 2, IS_LONG, 0) + ZEND_ARG_TYPE_INFO(0, lhs, IS_LONG, 0) + ZEND_ARG_TYPE_INFO(0, rhs, IS_LONG, 0) +ZEND_END_ARG_INFO() + ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class__ZendTestMagicCall___call, 0, 2, IS_MIXED, 0) ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0) ZEND_ARG_TYPE_INFO(0, args, IS_ARRAY, 0) @@ -254,6 +259,15 @@ ZEND_END_ARG_INFO() #define arginfo_class_ZendTestNS2_ZendSubNS_Foo_method arginfo_zend_test_void_return + +#if (PHP_VERSION_ID >= 80400) +ZEND_FRAMELESS_FUNCTION(_ZendTestClass_framelessStaticMethod, 2); +static const zend_frameless_function_info frameless_function_infos__ZendTestClass_framelessStaticMethod[] = { + { ZEND_FRAMELESS_FUNCTION_NAME(_ZendTestClass_framelessStaticMethod, 2), 2 }, + { 0 }, +}; +#endif + static ZEND_FUNCTION(zend_test_array_return); static ZEND_FUNCTION(zend_test_nullable_array_return); static ZEND_FUNCTION(zend_test_void_return); @@ -313,6 +327,7 @@ static ZEND_METHOD(_ZendTestClass, returnsStatic); static ZEND_METHOD(_ZendTestClass, returnsThrowable); static ZEND_METHOD(_ZendTestClass, variadicTest); static ZEND_METHOD(_ZendTestClass, takesUnionType); +static ZEND_METHOD(_ZendTestClass, framelessStaticMethod); static ZEND_METHOD(_ZendTestMagicCall, __call); static ZEND_METHOD(_ZendTestMagicCallForward, __call); static ZEND_METHOD(_ZendTestChildClass, returnsThrowable); @@ -458,6 +473,11 @@ static const zend_function_entry class__ZendTestClass_methods[] = { ZEND_ME(_ZendTestClass, returnsThrowable, arginfo_class__ZendTestClass_returnsThrowable, ZEND_ACC_PUBLIC) ZEND_ME(_ZendTestClass, variadicTest, arginfo_class__ZendTestClass_variadicTest, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) ZEND_ME(_ZendTestClass, takesUnionType, arginfo_class__ZendTestClass_takesUnionType, ZEND_ACC_PUBLIC) +#if (PHP_VERSION_ID >= 80400) + ZEND_RAW_FENTRY("framelessStaticMethod", zim__ZendTestClass_framelessStaticMethod, arginfo_class__ZendTestClass_framelessStaticMethod, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC, frameless_function_infos__ZendTestClass_framelessStaticMethod, NULL) +#else + ZEND_RAW_FENTRY("framelessStaticMethod", zim__ZendTestClass_framelessStaticMethod, arginfo_class__ZendTestClass_framelessStaticMethod, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) +#endif ZEND_FE_END }; diff --git a/ext/zend_test/tests/frameless_static_methods.phpt b/ext/zend_test/tests/frameless_static_methods.phpt new file mode 100644 index 0000000000000..39a1bbbf68fd5 --- /dev/null +++ b/ext/zend_test/tests/frameless_static_methods.phpt @@ -0,0 +1,12 @@ +--TEST-- +Frameless static methods +--EXTENSIONS-- +zend_test +--FILE-- + +--EXPECT-- +int(111)