From ec2eb7878f27fc677b2ef2da8e87629fdce3b052 Mon Sep 17 00:00:00 2001 From: Levi Morrison Date: Sat, 21 Jul 2018 17:21:01 -0600 Subject: [PATCH 01/19] Add covariance/contravariance to inherited methods Return types are covariant; parameter types are contravariant. --- Zend/tests/bug76451.inc | 4 + Zend/tests/bug76451.phpt | 20 + Zend/tests/object_types/object_variance.phpt | 22 + Zend/tests/return_types/008.phpt | 8 +- Zend/tests/return_types/generators003.phpt | 8 +- Zend/tests/return_types/inheritance005.phpt | 8 +- Zend/tests/return_types/inheritance006.phpt | 8 +- Zend/tests/return_types/inheritance007.phpt | 8 +- ...defined_type_during_variance_check_01.phpt | 15 + ...defined_type_during_variance_check_02.phpt | 15 + ...defined_type_during_variance_check_03.phpt | 15 + ...defined_type_during_variance_check_04.phpt | 16 + Zend/zend.c | 2 + Zend/zend_compile.c | 102 +- Zend/zend_globals.h | 1 + Zend/zend_inheritance.c | 409 +++- Zend/zend_inheritance.h | 1 + Zend/zend_vm_def.h | 16 + Zend/zend_vm_execute.h | 198 +- Zend/zend_vm_handlers.h | 1697 +++++++++-------- Zend/zend_vm_opcodes.c | 4 +- Zend/zend_vm_opcodes.h | 1 + 22 files changed, 1519 insertions(+), 1059 deletions(-) create mode 100644 Zend/tests/bug76451.inc create mode 100644 Zend/tests/bug76451.phpt create mode 100644 Zend/tests/object_types/object_variance.phpt create mode 100644 Zend/tests/typehints/undefined_type_during_variance_check_01.phpt create mode 100644 Zend/tests/typehints/undefined_type_during_variance_check_02.phpt create mode 100644 Zend/tests/typehints/undefined_type_during_variance_check_03.phpt create mode 100644 Zend/tests/typehints/undefined_type_during_variance_check_04.phpt diff --git a/Zend/tests/bug76451.inc b/Zend/tests/bug76451.inc new file mode 100644 index 0000000000000..18d3b50789056 --- /dev/null +++ b/Zend/tests/bug76451.inc @@ -0,0 +1,4 @@ + +--FILE-- + +--EXPECT-- diff --git a/Zend/tests/object_types/object_variance.phpt b/Zend/tests/object_types/object_variance.phpt new file mode 100644 index 0000000000000..3ab0a311bf3a9 --- /dev/null +++ b/Zend/tests/object_types/object_variance.phpt @@ -0,0 +1,22 @@ +--TEST-- +Testing object's variance in inheritance +--FILE-- +method1()); +?> +--EXPECT-- +C1 diff --git a/Zend/tests/return_types/008.phpt b/Zend/tests/return_types/008.phpt index a178607febc79..d5178ebd9da2e 100644 --- a/Zend/tests/return_types/008.phpt +++ b/Zend/tests/return_types/008.phpt @@ -14,6 +14,8 @@ class qux implements foo { } $qux = new qux(); -var_dump($qux->bar()); ---EXPECTF-- -Fatal error: Declaration of qux::bar(): qux must be compatible with foo::bar(): foo in %s008.php on line 8 +echo get_class($qux->bar()); + +?> +--EXPECT-- +qux diff --git a/Zend/tests/return_types/generators003.phpt b/Zend/tests/return_types/generators003.phpt index 489ef895a7391..3b524eff2b882 100644 --- a/Zend/tests/return_types/generators003.phpt +++ b/Zend/tests/return_types/generators003.phpt @@ -15,6 +15,8 @@ class SomeCollection implements Collection { } $some = new SomeCollection(); -var_dump($some->getIterator()); ---EXPECTF-- -Fatal error: Declaration of SomeCollection::getIterator(): Generator must be compatible with Collection::getIterator(): Iterator in %sgenerators003.php on line 7 +echo get_class($some->getIterator()); + +?> +--EXPECT-- +Generator diff --git a/Zend/tests/return_types/inheritance005.phpt b/Zend/tests/return_types/inheritance005.phpt index 6d8dfc8da9c8b..9793051da8fe3 100644 --- a/Zend/tests/return_types/inheritance005.phpt +++ b/Zend/tests/return_types/inheritance005.phpt @@ -13,5 +13,9 @@ class Bar extends Foo { return new Bar; } } ---EXPECTF-- -Fatal error: Declaration of Bar::test(): Bar must be compatible with Foo::test(): Foo in %sinheritance005.php on line 9 + +echo get_class(Bar::test()); + +?> +--EXPECT-- +Bar diff --git a/Zend/tests/return_types/inheritance006.phpt b/Zend/tests/return_types/inheritance006.phpt index 65cb1d2f7229a..8b7a37a1f4f22 100644 --- a/Zend/tests/return_types/inheritance006.phpt +++ b/Zend/tests/return_types/inheritance006.phpt @@ -17,5 +17,9 @@ class Bar extends Foo { return new B; } } ---EXPECTF-- -Fatal error: Declaration of Bar::test(): B must be compatible with Foo::test(): A in %sinheritance006.php on line 11 + +echo get_class(Bar::test()); + +?> +--EXPECT-- +B diff --git a/Zend/tests/return_types/inheritance007.phpt b/Zend/tests/return_types/inheritance007.phpt index d04ef71b1c21e..b08aaf9e99bcb 100644 --- a/Zend/tests/return_types/inheritance007.phpt +++ b/Zend/tests/return_types/inheritance007.phpt @@ -15,5 +15,9 @@ class Bar extends Foo { return new ArrayObject([1, 2]); } } ---EXPECTF-- -Fatal error: Declaration of Bar::test(): ArrayObject must be compatible with Foo::test(): Traversable in %sinheritance007.php on line 9 + +echo get_class(Bar::test()); + +?> +--EXPECT-- +ArrayObject diff --git a/Zend/tests/typehints/undefined_type_during_variance_check_01.phpt b/Zend/tests/typehints/undefined_type_during_variance_check_01.phpt new file mode 100644 index 0000000000000..b018d6c9cde13 --- /dev/null +++ b/Zend/tests/typehints/undefined_type_during_variance_check_01.phpt @@ -0,0 +1,15 @@ +--TEST-- +Undefined types during variance checks are warnings +--FILE-- + +--EXPECTF-- +Warning: Declaration of Y::m(UndefinedA $z) should be compatible with X::m(stdClass $z) in %s on line %d diff --git a/Zend/tests/typehints/undefined_type_during_variance_check_02.phpt b/Zend/tests/typehints/undefined_type_during_variance_check_02.phpt new file mode 100644 index 0000000000000..cf0c6aa5209a7 --- /dev/null +++ b/Zend/tests/typehints/undefined_type_during_variance_check_02.phpt @@ -0,0 +1,15 @@ +--TEST-- +Undefined types during variance checks are warnings +--FILE-- + +--EXPECTF-- +Warning: Declaration of Y::m(UndefinedA $z) should be compatible with X::m(stdClass $z) in %s on line %d diff --git a/Zend/tests/typehints/undefined_type_during_variance_check_03.phpt b/Zend/tests/typehints/undefined_type_during_variance_check_03.phpt new file mode 100644 index 0000000000000..6c14aa59ed448 --- /dev/null +++ b/Zend/tests/typehints/undefined_type_during_variance_check_03.phpt @@ -0,0 +1,15 @@ +--TEST-- +Undefined types during variance checks are errors +--FILE-- + +--EXPECTF-- +Fatal error: Declaration of Y::m(UndefinedA $z) must be compatible with X::m(stdClass $z) in %s on line %d diff --git a/Zend/tests/typehints/undefined_type_during_variance_check_04.phpt b/Zend/tests/typehints/undefined_type_during_variance_check_04.phpt new file mode 100644 index 0000000000000..f7c0e3042aec4 --- /dev/null +++ b/Zend/tests/typehints/undefined_type_during_variance_check_04.phpt @@ -0,0 +1,16 @@ +--TEST-- +Undefined types during variance checks are errors +--FILE-- + +--EXPECTF-- +Fatal error: Declaration of Y::m(UndefinedA $z) must be compatible with X::m(stdClass $z) in %s on line %d + diff --git a/Zend/zend.c b/Zend/zend.c index 36f47ee08fb7f..22cebcf15e239 100644 --- a/Zend/zend.c +++ b/Zend/zend.c @@ -629,6 +629,8 @@ static void compiler_globals_ctor(zend_compiler_globals *compiler_globals) /* {{ zend_hash_init_ex(compiler_globals->class_table, 64, NULL, ZEND_CLASS_DTOR, 1, 0); zend_hash_copy(compiler_globals->class_table, global_class_table, zend_class_add_ref); + compiler_globals->unverified_types = NULL; + zend_set_default_compile_time_values(); compiler_globals->auto_globals = (HashTable *) malloc(sizeof(HashTable)); diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 73ea21325c888..d19b3da65ff4f 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -3965,6 +3965,26 @@ void zend_compile_static_call(znode *result, zend_ast *ast, uint32_t type) /* {{ zend_op *zend_compile_class_decl(zend_ast *ast, zend_bool toplevel); +static +void _backup_unverified_variance_types(HashTable *unverified_types, + HashTable **prev_unverified_types) +{ + zend_hash_init(unverified_types, 0, NULL, NULL, 1); + *prev_unverified_types = CG(unverified_types); + CG(unverified_types) = unverified_types; +} + +static void _compile_verify_variance(HashTable *unverified_types) +{ + zend_string *lcname; + ZEND_HASH_FOREACH_STR_KEY(unverified_types, lcname) { + zend_op *opline = get_next_op(); + opline->op1_type = IS_CONST; + opline->opcode = ZEND_VERIFY_VARIANCE; + LITERAL_STR(opline->op1, zend_string_copy(lcname)); + } ZEND_HASH_FOREACH_END(); +} + void zend_compile_new(znode *result, zend_ast *ast) /* {{{ */ { zend_ast *class_ast = ast->child[0]; @@ -3974,11 +3994,22 @@ void zend_compile_new(znode *result, zend_ast *ast) /* {{{ */ zend_op *opline; if (class_ast->kind == ZEND_AST_CLASS) { + /* backup previous unverified variance list; anon classes are immediately verified */ + HashTable unverified_types; + HashTable *prev_unverified_types; + _backup_unverified_variance_types(&unverified_types, &prev_unverified_types); + /* jump over anon class declaration */ opline = zend_compile_class_decl(class_ast, 0); class_node.op_type = opline->result_type; class_node.u.op.var = opline->result.var; opline->extended_value = get_next_op_number(); + + _compile_verify_variance(&unverified_types); + + zend_hash_destroy(&unverified_types); + CG(unverified_types) = prev_unverified_types; + } else { zend_compile_class_ref(&class_node, class_ast, ZEND_FETCH_CLASS_EXCEPTION); } @@ -6308,6 +6339,14 @@ zend_op *zend_compile_class_decl(zend_ast *ast, zend_bool toplevel) /* {{{ */ ce->ce_flags |= ZEND_ACC_TOP_LEVEL; } + if (extends_ast || implements_ast) { + if (CG(unverified_types)) { + zend_hash_add_empty_element(CG(unverified_types), lcname); + } else { + // todo: figure out why it's null; need a caller (somewhere) to initialize, emit, and destroy the unverified types + } + } + if (toplevel /* We currently don't early-bind classes that implement interfaces or use traits */ && !(ce->ce_flags & (ZEND_ACC_IMPLEMENT_INTERFACES|ZEND_ACC_IMPLEMENT_TRAITS))) { @@ -8139,6 +8178,35 @@ void zend_const_expr_to_zval(zval *result, zend_ast *ast) /* {{{ */ } /* }}} */ +static zend_bool _is_type_decl(zend_ast *ast) { + return ast && ast->kind == ZEND_AST_CLASS; +} + +static zend_bool _is_not_decl_stmt(zend_ast *ast) { + if (ast) { + /* todo: what else should be considered a decl stmt? */ + switch (ast->kind) { + case ZEND_AST_FUNC_DECL: + case ZEND_AST_CLASS: + return 0; + + default: + return 1; + } + } + + /* todo: why are these sometimes null? */ + return 0; +} + +static zend_ast **_ast_find(zend_ast **begin, zend_ast **end, + zend_bool (*pred)(zend_ast *)) { + for (; begin < end; ++begin) + if (pred(*begin)) + return begin; + return begin; +} + /* Same as compile_stmt, but with early binding */ void zend_compile_top_stmt(zend_ast *ast) /* {{{ */ { @@ -8148,9 +8216,37 @@ void zend_compile_top_stmt(zend_ast *ast) /* {{{ */ if (ast->kind == ZEND_AST_STMT_LIST) { zend_ast_list *list = zend_ast_get_list(ast); - uint32_t i; - for (i = 0; i < list->children; ++i) { - zend_compile_top_stmt(list->child[i]); + zend_ast **begin = list->child; + zend_ast **end = begin + list->children; + zend_ast **first_decl = _ast_find(begin, end, &_is_type_decl); + zend_ast **last_decl = _ast_find(first_decl, end, &_is_not_decl_stmt); + zend_ast **p; + + /* Compile opcodes before first type decl */ + for (p = begin; p < first_decl; ++p) { + zend_compile_top_stmt(*p); + } + + /* Compile decl stmts */ + { + HashTable unverified_types; + HashTable *prev_unverified_types; + _backup_unverified_variance_types(&unverified_types, &prev_unverified_types); + + for (p = first_decl; p < last_decl; ++p) { + zend_compile_top_stmt(*p); + } + + _compile_verify_variance(&unverified_types); + + zend_hash_destroy(&unverified_types); + CG(unverified_types) = prev_unverified_types; + } + + /* Compile remainder */ + /* todo: loop to catch any non-consecutive type declarations */ + for (p = last_decl; p < end; ++p) { + zend_compile_top_stmt(*p); } return; } diff --git a/Zend/zend_globals.h b/Zend/zend_globals.h index 24ca1c52a2d65..ac449c0de1e60 100644 --- a/Zend/zend_globals.h +++ b/Zend/zend_globals.h @@ -67,6 +67,7 @@ struct _zend_compiler_globals { zend_stack loop_var_stack; zend_class_entry *active_class_entry; + HashTable *unverified_types; zend_string *compiled_filename; diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index 72bc9cfaae90e..10f04af7057ad 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -22,6 +22,7 @@ #include "zend_compile.h" #include "zend_execute.h" #include "zend_inheritance.h" +#include "zend_interfaces.h" #include "zend_smart_str.h" #include "zend_operators.h" @@ -183,72 +184,200 @@ static zend_always_inline zend_bool zend_iterable_compatibility_check(zend_arg_i } /* }}} */ -static int zend_do_perform_type_hint_check(const zend_function *fe, zend_arg_info *fe_arg_info, const zend_function *proto, zend_arg_info *proto_arg_info) /* {{{ */ +static +zend_string *_resolve_parent_and_self(const zend_function *fe, zend_string *name) { - ZEND_ASSERT(ZEND_TYPE_IS_SET(fe_arg_info->type) && ZEND_TYPE_IS_SET(proto_arg_info->type)); + zend_class_entry *ce = fe->common.scope; + /* if there isn't a class then we shouldn't be resolving parent and self */ + ZEND_ASSERT(fe->common.scope); + + switch (zend_get_class_fetch_type(name)) { + case ZEND_FETCH_CLASS_PARENT: + name = NULL; + if (ce->ce_flags & ZEND_ACC_LINKED) { + if (ce->parent && ce->parent->name) { + name = ce->parent->name; + } + } else if (ce->parent_name) { + name = ce->parent_name; + } + if (name == NULL) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot use parent as type constraint in %s::%s() because %s does not have a parent type", + ZEND_FN_SCOPE_NAME(fe), ZSTR_VAL(fe->common.function_name), + ZEND_FN_SCOPE_NAME(fe)); + } + break; - if (ZEND_TYPE_IS_CLASS(fe_arg_info->type) && ZEND_TYPE_IS_CLASS(proto_arg_info->type)) { - zend_string *fe_class_name, *proto_class_name; - const char *class_name; - size_t class_name_len; + case ZEND_FETCH_CLASS_SELF: + name = fe->common.scope->name; + break; - fe_class_name = ZEND_TYPE_NAME(fe_arg_info->type); - class_name = ZSTR_VAL(fe_class_name); - class_name_len = ZSTR_LEN(fe_class_name); - if (class_name_len == sizeof("parent")-1 && !strcasecmp(class_name, "parent") && proto->common.scope) { - fe_class_name = zend_string_copy(proto->common.scope->name); - } else if (class_name_len == sizeof("self")-1 && !strcasecmp(class_name, "self") && fe->common.scope) { - fe_class_name = zend_string_copy(fe->common.scope->name); - } else { - zend_string_addref(fe_class_name); - } + case ZEND_FETCH_CLASS_DEFAULT: + /* already resolved */ + break; + + case ZEND_FETCH_CLASS_STATIC: + /* Note: this currently a syntax error */ + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot use static as a type constraint in %s::%s()", + ZEND_FN_SCOPE_NAME(fe), ZSTR_VAL(fe->common.function_name)); + + EMPTY_SWITCH_DEFAULT_CASE(); + } + + return zend_string_copy(name); +} + +typedef enum { + CONTRAVARIANT = -1, + INVARIANT = 0, + COVARIANT = +1, +} _variance; + +static +int _check_zce_variance( + const zend_class_entry *ce1, const zend_class_entry *ce2, + _variance variance) /* {{{ */ +{ + if (ce1 == ce2) return 1; + + switch (variance) { + case INVARIANT: + // todo: does ce1 == ce2 above catch all possible cases? + return 0; + case COVARIANT: + return instanceof_function(ce1, ce2); + case CONTRAVARIANT: + return instanceof_function(ce2, ce1); + + EMPTY_SWITCH_DEFAULT_CASE(); + } +} + +/* This int return is not a boolean, but will often be treated this way. + * * 0 means there is definitely an error. + * * 1 means there are definitely not any errors. + * * -1 means there are no known errors but it is not known to be good + * either (there is not enough information at the moment). + */ +static +int _check_inherited_arg_info( + const zend_function *fe, zend_arg_info *fe_arg_info, + const zend_function *proto, zend_arg_info *proto_arg_info, + _variance variance) /* {{{ */ +{ + zend_type fe_type = fe_arg_info->type; + zend_type proto_type = proto_arg_info->type; + zend_long fe_type_code = ZEND_TYPE_CODE(fe_type); + zend_long proto_type_code = ZEND_TYPE_CODE(proto_type); + + ZEND_ASSERT(ZEND_TYPE_IS_SET(fe_type)); + ZEND_ASSERT(ZEND_TYPE_IS_SET(proto_type)); + + if (variance == COVARIANT && ZEND_TYPE_ALLOW_NULL(fe_type) && !ZEND_TYPE_ALLOW_NULL(proto_type)) { + return 0; + } + + /* This introduces BC break described at https://bugs.php.net/bug.php?id=72119 */ + if (variance == CONTRAVARIANT && ZEND_TYPE_ALLOW_NULL(proto_type) && !ZEND_TYPE_ALLOW_NULL(fe_type)) { + return 0; + } + + if (ZEND_TYPE_IS_CLASS(fe_type)) { + zend_string *fe_class_name = + _resolve_parent_and_self(fe, ZEND_TYPE_NAME(fe_type)); + int code = 1; + if (ZEND_TYPE_IS_CLASS(proto_type)) { + zend_string *proto_class_name = + _resolve_parent_and_self(proto, ZEND_TYPE_NAME(proto_type)); - proto_class_name = ZEND_TYPE_NAME(proto_arg_info->type); - class_name = ZSTR_VAL(proto_class_name); - class_name_len = ZSTR_LEN(proto_class_name); - if (class_name_len == sizeof("parent")-1 && !strcasecmp(class_name, "parent") && proto->common.scope && proto->common.scope->parent) { - proto_class_name = zend_string_copy(proto->common.scope->parent->name); - } else if (class_name_len == sizeof("self")-1 && !strcasecmp(class_name, "self") && proto->common.scope) { - proto_class_name = zend_string_copy(proto->common.scope->name); + if (!zend_string_equals_ci(fe_class_name, proto_class_name)) { + if (fe->common.type == ZEND_USER_FUNCTION) { + zend_class_entry * fe_ce = zend_lookup_class(fe_class_name); + zend_class_entry * proto_ce = zend_lookup_class(proto_class_name); + + if (fe_ce && proto_ce) { + code = _check_zce_variance(fe_ce, proto_ce, variance); + } else { + /* The -1 will still be considered "truthy". It means there + * is not enough information at the moment, but there are + * not any known errors either. */ + code = -1; + } + } else { + code = 0; + } + } + zend_string_release(proto_class_name); + } else if (variance == COVARIANT) { + if (proto_type_code == IS_ITERABLE) { + zend_class_entry * fe_ce = zend_lookup_class(fe_class_name); + code = fe_ce ? instanceof_function(fe_ce, zend_ce_traversable) : -1; + } else if (proto_type_code != IS_OBJECT) { + code = 0; + } } else { - zend_string_addref(proto_class_name); + code = 0; } - if (fe_class_name != proto_class_name && strcasecmp(ZSTR_VAL(fe_class_name), ZSTR_VAL(proto_class_name)) != 0) { - if (fe->common.type != ZEND_USER_FUNCTION) { + zend_string_release(fe_class_name); + return code; + } else if (ZEND_TYPE_IS_CLASS(proto_type)) { + if (variance == CONTRAVARIANT) { + if (fe_type_code == IS_ITERABLE) { + zend_string *proto_class_name = + _resolve_parent_and_self(proto, ZEND_TYPE_NAME(proto_type)); + zend_class_entry *proto_ce = zend_lookup_class(proto_class_name); zend_string_release(proto_class_name); - zend_string_release(fe_class_name); - return 0; - } else { - zend_class_entry *fe_ce, *proto_ce; - - fe_ce = zend_lookup_class(fe_class_name); - proto_ce = zend_lookup_class(proto_class_name); - - /* Check for class alias */ - if (!fe_ce || !proto_ce || - fe_ce->type == ZEND_INTERNAL_CLASS || - proto_ce->type == ZEND_INTERNAL_CLASS || - fe_ce != proto_ce) { - zend_string_release(proto_class_name); - zend_string_release(fe_class_name); - return 0; - } + return proto_ce + ? instanceof_function(proto_ce, zend_ce_traversable) + : -1; + } else if (fe_type_code == IS_OBJECT) { + return 1; } } - zend_string_release(proto_class_name); - zend_string_release(fe_class_name); - } else if (ZEND_TYPE_CODE(fe_arg_info->type) != ZEND_TYPE_CODE(proto_arg_info->type)) { - /* Incompatible built-in types */ + } else if (fe_type_code == IS_ITERABLE || proto_type_code == IS_ITERABLE) { + return (variance == COVARIANT && fe_type_code == IS_ARRAY) + || (variance == CONTRAVARIANT && proto_type_code == IS_ARRAY); + } else if (fe_type_code == proto_type_code) { + return 1; + } + + return 0; +} + /* }}} */ + +static +int _check_inherited_return_type( + const zend_function *fe, zend_arg_info *fe_arg_info, + const zend_function *proto, zend_arg_info *proto_arg_info) /* {{{ */ +{ + /* Removing a return type is not valid. */ + if (!(fe->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE)) { return 0; } - return 1; + return _check_inherited_arg_info(fe, fe_arg_info, proto, proto_arg_info, COVARIANT); +} + + +static zend_bool _missing_internal_arginfo(zend_function const *fn) +{ + return !fn->common.arg_info && fn->common.type == ZEND_INTERNAL_FUNCTION; } -/* }}} */ -static int zend_do_perform_arg_type_hint_check(const zend_function *fe, zend_arg_info *fe_arg_info, const zend_function *proto, zend_arg_info *proto_arg_info) /* {{{ */ +static +int _check_inherited_parameter_type( + const zend_function *fe, zend_arg_info *fe_arg_info, + const zend_function *proto, zend_arg_info *proto_arg_info) /* {{{ */ { + + /* by-ref constraints on arguments are invariant */ + if (fe_arg_info->pass_by_reference != proto_arg_info->pass_by_reference) { + return 0; + } + if (!ZEND_TYPE_IS_SET(fe_arg_info->type)) { /* Child with no type is always compatible */ return 1; @@ -259,11 +388,11 @@ static int zend_do_perform_arg_type_hint_check(const zend_function *fe, zend_arg return 0; } - return zend_do_perform_type_hint_check(fe, fe_arg_info, proto, proto_arg_info); + return _check_inherited_arg_info(fe, fe_arg_info, proto, proto_arg_info, CONTRAVARIANT); } /* }}} */ -static zend_bool zend_do_perform_implementation_check(const zend_function *fe, const zend_function *proto) /* {{{ */ +static int zend_do_perform_implementation_check(const zend_function *fe, const zend_function *proto) /* {{{ */ { uint32_t i, num_args; @@ -271,7 +400,7 @@ static zend_bool zend_do_perform_implementation_check(const zend_function *fe, c * we still need to do the arg number checks. We are only willing to ignore this for internal * functions because extensions don't always define arg_info. */ - if (!proto->common.arg_info && proto->common.type != ZEND_USER_FUNCTION) { + if (_missing_internal_arginfo(proto)) { return 1; } @@ -313,7 +442,7 @@ static zend_bool zend_do_perform_implementation_check(const zend_function *fe, c num_args = proto->common.num_args; if (proto->common.fn_flags & ZEND_ACC_VARIADIC) { num_args++; - if (fe->common.num_args >= proto->common.num_args) { + if (fe->common.num_args >= proto->common.num_args) { num_args = fe->common.num_args; if (fe->common.fn_flags & ZEND_ACC_VARIADIC) { num_args++; @@ -323,35 +452,11 @@ static zend_bool zend_do_perform_implementation_check(const zend_function *fe, c for (i = 0; i < num_args; i++) { zend_arg_info *fe_arg_info = &fe->common.arg_info[i]; + zend_arg_info *proto_arg_info = (i < proto->common.num_args) + ? &proto->common.arg_info[i] + : &proto->common.arg_info[proto->common.num_args]; - zend_arg_info *proto_arg_info; - if (i < proto->common.num_args) { - proto_arg_info = &proto->common.arg_info[i]; - } else { - proto_arg_info = &proto->common.arg_info[proto->common.num_args]; - } - - if (!zend_do_perform_arg_type_hint_check(fe, fe_arg_info, proto, proto_arg_info)) { - switch (ZEND_TYPE_CODE(fe_arg_info->type)) { - case IS_ITERABLE: - if (!zend_iterable_compatibility_check(proto_arg_info)) { - return 0; - } - break; - - default: - return 0; - } - } - - // This introduces BC break described at https://bugs.php.net/bug.php?id=72119 - if (ZEND_TYPE_IS_SET(proto_arg_info->type) && ZEND_TYPE_ALLOW_NULL(proto_arg_info->type) && !ZEND_TYPE_ALLOW_NULL(fe_arg_info->type)) { - /* incompatible nullability */ - return 0; - } - - /* by-ref constraints on arguments are invariant */ - if (fe_arg_info->pass_by_reference != proto_arg_info->pass_by_reference) { + if (!_check_inherited_parameter_type(fe, fe_arg_info, proto, proto_arg_info)) { return 0; } } @@ -359,27 +464,8 @@ static zend_bool zend_do_perform_implementation_check(const zend_function *fe, c /* Check return type compatibility, but only if the prototype already specifies * a return type. Adding a new return type is always valid. */ if (proto->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) { - /* Removing a return type is not valid. */ - if (!(fe->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE)) { - return 0; - } - - if (!zend_do_perform_type_hint_check(fe, fe->common.arg_info - 1, proto, proto->common.arg_info - 1)) { - switch (ZEND_TYPE_CODE(proto->common.arg_info[-1].type)) { - case IS_ITERABLE: - if (!zend_iterable_compatibility_check(fe->common.arg_info - 1)) { - return 0; - } - break; - - default: - return 0; - } - } - - if (ZEND_TYPE_ALLOW_NULL(fe->common.arg_info[-1].type) && !ZEND_TYPE_ALLOW_NULL(proto->common.arg_info[-1].type)) { - return 0; - } + return _check_inherited_return_type( + fe, fe->common.arg_info - 1, proto, proto->common.arg_info - 1); } return 1; } @@ -644,9 +730,7 @@ static void do_inheritance_check_on_method(zend_function *child, zend_function * error_level = E_COMPILE_ERROR; error_verb = "must"; } else if ((parent->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) && - (!(child->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || - !zend_do_perform_type_hint_check(child, child->common.arg_info - 1, parent, parent->common.arg_info - 1) || - (ZEND_TYPE_ALLOW_NULL(child->common.arg_info[-1].type) && !ZEND_TYPE_ALLOW_NULL(parent->common.arg_info[-1].type)))) { + !_check_inherited_return_type(child, child->common.arg_info - 1, parent, parent->common.arg_info - 1)) { error_level = E_COMPILE_ERROR; error_verb = "must"; } else { @@ -2076,3 +2160,116 @@ ZEND_API void zend_do_link_class(zend_class_entry *ce, zend_class_entry *parent) zend_build_properties_info_table(ce); } /* }}} */ + +static void _inheritance_runtime_error_msg(zend_function *child, zend_function *parent) +{ + int level = E_WARNING; + const char *verb = "should"; + ZEND_ASSERT(child && parent); + if ((parent->common.fn_flags & ZEND_ACC_ABSTRACT) + || ((parent->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE))) + { + level = E_ERROR; + verb = "must"; + } + { + zend_string *method_prototype = zend_get_function_declaration(parent); + zend_string *child_prototype = zend_get_function_declaration(child); + zend_error(level, "Declaration of %s %s be compatible with %s", + ZSTR_VAL(child_prototype), verb, ZSTR_VAL(method_prototype)); + zend_string_efree(child_prototype); + zend_string_efree(method_prototype); + } +} + +ZEND_API void zend_verify_variance(zend_class_entry *ce) +{ /* {{{ */ + // todo: name? "verify" typically means something else + // todo: de-duplicate all this + zend_function *child; + ZEND_ASSERT(ce->ce_flags & ZEND_ACC_LINKED); + + ZEND_HASH_FOREACH_PTR(&ce->function_table, child) { + zend_function *parent = child->common.prototype; + if (!parent) { + continue; + } + + /* We are only willing to ignore this for internal functions because + * extensions don't always define arg_info. */ + if (_missing_internal_arginfo(parent)) { + continue; + } + + /* If the parenttype method is private do not enforce a signature */ + if (!(parent->common.fn_flags & ZEND_ACC_PRIVATE)) { + uint32_t i, num_args; + + /* Checks for constructors only if they are declared in an interface, + * or explicitly marked as abstract + */ + if ((ce->constructor == child) + && ((parent->common.scope->ce_flags & ZEND_ACC_INTERFACE) == 0 + && (parent->common.fn_flags & ZEND_ACC_ABSTRACT) == 0)) + { + continue; + } + + /* Check return type compatibility, but only if the prototype already + * specifies a return type. Adding a new return type is always valid. */ + if (parent->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) { + if (child->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) { + int check = _check_inherited_return_type( + child, &child->common.arg_info[-1], + parent, &parent->common.arg_info[-1]); + if (check < 0) { + _inheritance_runtime_error_msg(child, parent); + // todo: what to do with errors, not warnings? + continue; + } + } else { + // This branch should already have been taken care of + continue; + } + } + + if (parent->common.required_num_args < child->common.required_num_args + || parent->common.num_args > child->common.num_args) + { + // This branch should already have been taken care of + continue; + } + + num_args = parent->common.num_args; + if (parent->common.fn_flags & ZEND_ACC_VARIADIC) { + num_args++; + if (child->common.num_args >= parent->common.num_args) { + num_args = child->common.num_args; + if (child->common.fn_flags & ZEND_ACC_VARIADIC) { + num_args++; + } + } + } + + for (i = 0; i < num_args; i++) { + zend_arg_info *child_arg_info = &child->common.arg_info[i]; + zend_arg_info *parent_arg_info = (i < parent->common.num_args) + ? &parent->common.arg_info[i] + : &parent->common.arg_info[parent->common.num_args]; + + int check = _check_inherited_parameter_type( + child, child_arg_info, + parent, parent_arg_info); + + if (check < 0) { + _inheritance_runtime_error_msg(child, parent); + // todo: what to do with errors, not warnings? + continue; + } + } + + } + } ZEND_HASH_FOREACH_END(); + +} +/* }}} */ diff --git a/Zend/zend_inheritance.h b/Zend/zend_inheritance.h index 9f3668191a793..d75f6d247ef61 100644 --- a/Zend/zend_inheritance.h +++ b/Zend/zend_inheritance.h @@ -28,6 +28,7 @@ ZEND_API void zend_do_implement_interface(zend_class_entry *ce, zend_class_entry ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent_ce); ZEND_API void zend_do_link_class(zend_class_entry *ce, zend_class_entry *parent_ce); +ZEND_API void zend_verify_variance(zend_class_entry *ce); void zend_verify_abstract_class(zend_class_entry *ce); void zend_check_deprecated_constructor(const zend_class_entry *ce); diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 60c77ce8ae12a..1474e3db8028f 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -6948,6 +6948,22 @@ ZEND_VM_HANDLER(145, ZEND_DECLARE_INHERITED_CLASS_DELAYED, CONST, CONST) ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +ZEND_VM_HANDLER(146, ZEND_VERIFY_VARIANCE, CONST, UNUSED) +{ + USE_OPLINE + zend_class_entry *zce; + + SAVE_OPLINE(); + zce = zend_lookup_class(Z_STR_P(RT_CONSTANT(opline, opline->op1))); + if (zce) { + zend_verify_variance(zce); + } else { + ZEND_ASSERT(EG(exception)); + HANDLE_EXCEPTION(); + } + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + ZEND_VM_HANDLER(171, ZEND_DECLARE_ANON_CLASS, ANY, ANY, JMP_ADDR) { zval *zv; diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index f160de75d1d4a..c6b80e803b751 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -9302,6 +9302,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_U } /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_VARIANCE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_class_entry *zce; + + SAVE_OPLINE(); + zce = zend_lookup_class(Z_STR_P(RT_CONSTANT(opline, opline->op1))); + if (zce) { + zend_verify_variance(zce); + } else { + ZEND_ASSERT(EG(exception)); + HANDLE_EXCEPTION(); + } + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -56904,6 +56920,7 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_YIELD_FROM_SPEC_CV_LABEL, (void*)&&ZEND_DECLARE_CONST_SPEC_CONST_CONST_LABEL, (void*)&&ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_CONST_CONST_LABEL, + (void*)&&ZEND_VERIFY_VARIANCE_SPEC_CONST_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -59859,6 +59876,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_VERIFY_VARIANCE_SPEC_CONST_UNUSED): + VM_TRACE(ZEND_VERIFY_VARIANCE_SPEC_CONST_UNUSED) + ZEND_VERIFY_VARIANCE_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED): VM_TRACE(ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -67756,6 +67777,7 @@ void zend_vm_init(void) ZEND_YIELD_FROM_SPEC_CV_HANDLER, ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER, + ZEND_VERIFY_VARIANCE_SPEC_CONST_UNUSED_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, @@ -69639,71 +69661,71 @@ void zend_vm_init(void) 2705, 2706 | SPEC_RULE_OP1, 2711, - 4449, + 4450, 2712, - 4449, - 2713 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA, - 2838 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2863, + 2713, + 2714 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA, + 2839 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 2864, 2865, - 2866 | SPEC_RULE_OP1, - 2871, - 4449, - 4449, + 2866, + 2867 | SPEC_RULE_OP1, 2872, + 4450, + 4450, 2873, 2874, 2875, - 2876 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2901 | SPEC_RULE_OP1, - 2906, + 2876, + 2877 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2902 | SPEC_RULE_OP1, 2907, 2908, 2909, - 2910 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2935 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ, - 3035, - 3036 | SPEC_RULE_OP1, - 3041 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3066, + 2910, + 2911 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2936 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ, + 3036, + 3037 | SPEC_RULE_OP1, + 3042 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 3067, - 3068 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3093 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3118 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3143 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3168 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3193 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3218 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3243, - 3244 | SPEC_RULE_OP1, - 3249, + 3068, + 3069 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 3094 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 3119 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 3144 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 3169 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 3194 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 3219 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 3244, + 3245 | SPEC_RULE_OP1, 3250, 3251, 3252, 3253, - 3254 | SPEC_RULE_OP1, - 3259 | SPEC_RULE_OP1, - 3264 | SPEC_RULE_OP1, - 3269 | SPEC_RULE_OP1, - 3274 | SPEC_RULE_OP1, - 3279, - 3280 | SPEC_RULE_OP1, - 3285, - 3286 | SPEC_RULE_OP1, - 3291, - 3292 | SPEC_RULE_ISSET, - 3294 | SPEC_RULE_OP2, - 3299 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3324 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA, - 3449 | SPEC_RULE_OP_DATA, - 3454, - 3455 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3480 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3505 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3530 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3555, - 4449 + 3254, + 3255 | SPEC_RULE_OP1, + 3260 | SPEC_RULE_OP1, + 3265 | SPEC_RULE_OP1, + 3270 | SPEC_RULE_OP1, + 3275 | SPEC_RULE_OP1, + 3280, + 3281 | SPEC_RULE_OP1, + 3286, + 3287 | SPEC_RULE_OP1, + 3292, + 3293 | SPEC_RULE_ISSET, + 3295 | SPEC_RULE_OP2, + 3300 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 3325 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA, + 3450 | SPEC_RULE_OP_DATA, + 3455, + 3456 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 3481 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 3506 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 3531 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 3556, + 4450 }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -69910,7 +69932,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3557 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3558 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -69918,7 +69940,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3582 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3583 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -69926,7 +69948,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3607 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3608 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -69937,17 +69959,17 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3632 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3633 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3657 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3658 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3682 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3683 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -69958,17 +69980,17 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3707 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3708 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3732 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3733 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3757 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3758 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -69979,12 +70001,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3782 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3783 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3857 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3858 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -69995,12 +70017,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3932 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3933 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 4007 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 4008 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -70008,12 +70030,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 4082 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 4083 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 4157 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 4158 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -70021,75 +70043,75 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 4232 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 4233 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 4307 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 4308 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_DOUBLE) { - spec = 4400 | SPEC_RULE_OP1; + spec = 4401 | SPEC_RULE_OP1; } else if ((op->op1_type == IS_CONST) ? !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1)) : (!(op1_info & ((MAY_BE_ANY|MAY_BE_UNDEF)-(MAY_BE_NULL|MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_LONG|MAY_BE_DOUBLE))))) { - spec = 4405 | SPEC_RULE_OP1; + spec = 4406 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 4382 | SPEC_RULE_RETVAL; + spec = 4383 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 4384 | SPEC_RULE_RETVAL; + spec = 4385 | SPEC_RULE_RETVAL; } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) { - spec = 4386 | SPEC_RULE_RETVAL; + spec = 4387 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 4388 | SPEC_RULE_RETVAL; + spec = 4389 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 4390 | SPEC_RULE_RETVAL; + spec = 4391 | SPEC_RULE_RETVAL; } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) { - spec = 4392 | SPEC_RULE_RETVAL; + spec = 4393 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 4394; - } else if (op1_info == MAY_BE_LONG) { spec = 4395; - } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) { + } else if (op1_info == MAY_BE_LONG) { spec = 4396; + } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) { + spec = 4397; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 4397; - } else if (op1_info == MAY_BE_LONG) { spec = 4398; - } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) { + } else if (op1_info == MAY_BE_LONG) { spec = 4399; + } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) { + spec = 4400; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 3556; + spec = 3557; } break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 4445; + spec = 4446; } break; case ZEND_SEND_VAR_EX: if (op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 4440 | SPEC_RULE_OP1; + spec = 4441 | SPEC_RULE_OP1; } break; case ZEND_FE_FETCH_R: if (op->op2_type == IS_CV && (op1_info & (MAY_BE_UNDEF|MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 4447 | SPEC_RULE_RETVAL; + spec = 4448 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -70097,17 +70119,17 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 4410 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 4411 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_SEND_VAL_EX: if (op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 4446; + spec = 4447; } break; case ZEND_SEND_VAR: if ((op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 4435 | SPEC_RULE_OP1; + spec = 4436 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 0fd402eeab833..38246b4d97d33 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -1423,908 +1423,909 @@ _(2710, ZEND_YIELD_FROM_SPEC_CV) \ _(2711, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ _(2712, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_CONST_CONST) \ - _(2763, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST) \ - _(2764, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP) \ - _(2765, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR) \ - _(2767, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV) \ - _(2768, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST) \ - _(2769, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP) \ - _(2770, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ - _(2772, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV) \ - _(2773, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST) \ - _(2774, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP) \ - _(2775, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ - _(2777, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV) \ - _(2778, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST) \ - _(2779, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP) \ - _(2780, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR) \ - _(2782, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV) \ - _(2783, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST) \ - _(2784, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP) \ - _(2785, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR) \ - _(2787, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV) \ - _(2813, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST) \ - _(2814, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP) \ - _(2815, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR) \ - _(2817, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV) \ - _(2818, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST) \ - _(2819, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP) \ - _(2820, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR) \ - _(2822, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV) \ - _(2823, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST) \ - _(2824, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP) \ - _(2825, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR) \ - _(2827, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV) \ - _(2828, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST) \ - _(2829, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP) \ - _(2830, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR) \ - _(2832, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV) \ - _(2833, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST) \ - _(2834, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP) \ - _(2835, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR) \ - _(2837, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV) \ - _(2838, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ - _(2839, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ + _(2713, ZEND_VERIFY_VARIANCE_SPEC_CONST_UNUSED) \ + _(2764, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST) \ + _(2765, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP) \ + _(2766, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR) \ + _(2768, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV) \ + _(2769, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST) \ + _(2770, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP) \ + _(2771, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ + _(2773, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV) \ + _(2774, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST) \ + _(2775, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP) \ + _(2776, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ + _(2778, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV) \ + _(2779, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST) \ + _(2780, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP) \ + _(2781, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR) \ + _(2783, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV) \ + _(2784, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST) \ + _(2785, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP) \ + _(2786, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR) \ + _(2788, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV) \ + _(2814, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST) \ + _(2815, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP) \ + _(2816, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR) \ + _(2818, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV) \ + _(2819, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST) \ + _(2820, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP) \ + _(2821, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR) \ + _(2823, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV) \ + _(2824, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST) \ + _(2825, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP) \ + _(2826, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR) \ + _(2828, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV) \ + _(2829, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST) \ + _(2830, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP) \ + _(2831, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR) \ + _(2833, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV) \ + _(2834, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST) \ + _(2835, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP) \ + _(2836, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR) \ + _(2838, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV) \ + _(2839, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ _(2840, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ - _(2842, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ - _(2843, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ - _(2844, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2841, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ + _(2843, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ + _(2844, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ _(2845, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2847, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ - _(2848, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ - _(2849, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2846, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2848, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ + _(2849, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ _(2850, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2852, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ - _(2853, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ - _(2854, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2851, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2853, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ + _(2854, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ _(2855, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2857, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ - _(2858, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ - _(2859, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ + _(2856, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2858, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ + _(2859, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ _(2860, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ - _(2862, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ - _(2863, ZEND_HANDLE_EXCEPTION_SPEC) \ - _(2864, ZEND_USER_OPCODE_SPEC) \ - _(2865, ZEND_ASSERT_CHECK_SPEC) \ - _(2866, ZEND_JMP_SET_SPEC_CONST) \ - _(2867, ZEND_JMP_SET_SPEC_TMP) \ - _(2868, ZEND_JMP_SET_SPEC_VAR) \ - _(2870, ZEND_JMP_SET_SPEC_CV) \ - _(2871, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) \ - _(2872, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ - _(2873, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ - _(2874, ZEND_CALL_TRAMPOLINE_SPEC) \ - _(2875, ZEND_DISCARD_EXCEPTION_SPEC) \ - _(2876, ZEND_YIELD_SPEC_CONST_CONST) \ - _(2877, ZEND_YIELD_SPEC_CONST_TMP) \ - _(2878, ZEND_YIELD_SPEC_CONST_VAR) \ - _(2879, ZEND_YIELD_SPEC_CONST_UNUSED) \ - _(2880, ZEND_YIELD_SPEC_CONST_CV) \ - _(2881, ZEND_YIELD_SPEC_TMP_CONST) \ - _(2882, ZEND_YIELD_SPEC_TMP_TMP) \ - _(2883, ZEND_YIELD_SPEC_TMP_VAR) \ - _(2884, ZEND_YIELD_SPEC_TMP_UNUSED) \ - _(2885, ZEND_YIELD_SPEC_TMP_CV) \ - _(2886, ZEND_YIELD_SPEC_VAR_CONST) \ - _(2887, ZEND_YIELD_SPEC_VAR_TMP) \ - _(2888, ZEND_YIELD_SPEC_VAR_VAR) \ - _(2889, ZEND_YIELD_SPEC_VAR_UNUSED) \ - _(2890, ZEND_YIELD_SPEC_VAR_CV) \ - _(2891, ZEND_YIELD_SPEC_UNUSED_CONST) \ - _(2892, ZEND_YIELD_SPEC_UNUSED_TMP) \ - _(2893, ZEND_YIELD_SPEC_UNUSED_VAR) \ - _(2894, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ - _(2895, ZEND_YIELD_SPEC_UNUSED_CV) \ - _(2896, ZEND_YIELD_SPEC_CV_CONST) \ - _(2897, ZEND_YIELD_SPEC_CV_TMP) \ - _(2898, ZEND_YIELD_SPEC_CV_VAR) \ - _(2899, ZEND_YIELD_SPEC_CV_UNUSED) \ - _(2900, ZEND_YIELD_SPEC_CV_CV) \ - _(2901, ZEND_GENERATOR_RETURN_SPEC_CONST) \ - _(2902, ZEND_GENERATOR_RETURN_SPEC_TMP) \ - _(2903, ZEND_GENERATOR_RETURN_SPEC_VAR) \ - _(2905, ZEND_GENERATOR_RETURN_SPEC_CV) \ - _(2906, ZEND_FAST_CALL_SPEC) \ - _(2907, ZEND_FAST_RET_SPEC) \ - _(2908, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ - _(2909, ZEND_SEND_UNPACK_SPEC) \ - _(2910, ZEND_POW_SPEC_CONST_CONST) \ - _(2911, ZEND_POW_SPEC_CONST_TMPVAR) \ + _(2861, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ + _(2863, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ + _(2864, ZEND_HANDLE_EXCEPTION_SPEC) \ + _(2865, ZEND_USER_OPCODE_SPEC) \ + _(2866, ZEND_ASSERT_CHECK_SPEC) \ + _(2867, ZEND_JMP_SET_SPEC_CONST) \ + _(2868, ZEND_JMP_SET_SPEC_TMP) \ + _(2869, ZEND_JMP_SET_SPEC_VAR) \ + _(2871, ZEND_JMP_SET_SPEC_CV) \ + _(2872, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) \ + _(2873, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ + _(2874, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ + _(2875, ZEND_CALL_TRAMPOLINE_SPEC) \ + _(2876, ZEND_DISCARD_EXCEPTION_SPEC) \ + _(2877, ZEND_YIELD_SPEC_CONST_CONST) \ + _(2878, ZEND_YIELD_SPEC_CONST_TMP) \ + _(2879, ZEND_YIELD_SPEC_CONST_VAR) \ + _(2880, ZEND_YIELD_SPEC_CONST_UNUSED) \ + _(2881, ZEND_YIELD_SPEC_CONST_CV) \ + _(2882, ZEND_YIELD_SPEC_TMP_CONST) \ + _(2883, ZEND_YIELD_SPEC_TMP_TMP) \ + _(2884, ZEND_YIELD_SPEC_TMP_VAR) \ + _(2885, ZEND_YIELD_SPEC_TMP_UNUSED) \ + _(2886, ZEND_YIELD_SPEC_TMP_CV) \ + _(2887, ZEND_YIELD_SPEC_VAR_CONST) \ + _(2888, ZEND_YIELD_SPEC_VAR_TMP) \ + _(2889, ZEND_YIELD_SPEC_VAR_VAR) \ + _(2890, ZEND_YIELD_SPEC_VAR_UNUSED) \ + _(2891, ZEND_YIELD_SPEC_VAR_CV) \ + _(2892, ZEND_YIELD_SPEC_UNUSED_CONST) \ + _(2893, ZEND_YIELD_SPEC_UNUSED_TMP) \ + _(2894, ZEND_YIELD_SPEC_UNUSED_VAR) \ + _(2895, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ + _(2896, ZEND_YIELD_SPEC_UNUSED_CV) \ + _(2897, ZEND_YIELD_SPEC_CV_CONST) \ + _(2898, ZEND_YIELD_SPEC_CV_TMP) \ + _(2899, ZEND_YIELD_SPEC_CV_VAR) \ + _(2900, ZEND_YIELD_SPEC_CV_UNUSED) \ + _(2901, ZEND_YIELD_SPEC_CV_CV) \ + _(2902, ZEND_GENERATOR_RETURN_SPEC_CONST) \ + _(2903, ZEND_GENERATOR_RETURN_SPEC_TMP) \ + _(2904, ZEND_GENERATOR_RETURN_SPEC_VAR) \ + _(2906, ZEND_GENERATOR_RETURN_SPEC_CV) \ + _(2907, ZEND_FAST_CALL_SPEC) \ + _(2908, ZEND_FAST_RET_SPEC) \ + _(2909, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ + _(2910, ZEND_SEND_UNPACK_SPEC) \ + _(2911, ZEND_POW_SPEC_CONST_CONST) \ _(2912, ZEND_POW_SPEC_CONST_TMPVAR) \ - _(2914, ZEND_POW_SPEC_CONST_CV) \ - _(2915, ZEND_POW_SPEC_TMPVAR_CONST) \ - _(2916, ZEND_POW_SPEC_TMPVAR_TMPVAR) \ + _(2913, ZEND_POW_SPEC_CONST_TMPVAR) \ + _(2915, ZEND_POW_SPEC_CONST_CV) \ + _(2916, ZEND_POW_SPEC_TMPVAR_CONST) \ _(2917, ZEND_POW_SPEC_TMPVAR_TMPVAR) \ - _(2919, ZEND_POW_SPEC_TMPVAR_CV) \ - _(2920, ZEND_POW_SPEC_TMPVAR_CONST) \ - _(2921, ZEND_POW_SPEC_TMPVAR_TMPVAR) \ + _(2918, ZEND_POW_SPEC_TMPVAR_TMPVAR) \ + _(2920, ZEND_POW_SPEC_TMPVAR_CV) \ + _(2921, ZEND_POW_SPEC_TMPVAR_CONST) \ _(2922, ZEND_POW_SPEC_TMPVAR_TMPVAR) \ - _(2924, ZEND_POW_SPEC_TMPVAR_CV) \ - _(2930, ZEND_POW_SPEC_CV_CONST) \ - _(2931, ZEND_POW_SPEC_CV_TMPVAR) \ + _(2923, ZEND_POW_SPEC_TMPVAR_TMPVAR) \ + _(2925, ZEND_POW_SPEC_TMPVAR_CV) \ + _(2931, ZEND_POW_SPEC_CV_CONST) \ _(2932, ZEND_POW_SPEC_CV_TMPVAR) \ - _(2934, ZEND_POW_SPEC_CV_CV) \ - _(2938, ZEND_ASSIGN_POW_SPEC_CONST_CONST_STATIC_PROP) \ - _(2942, ZEND_ASSIGN_POW_SPEC_CONST_TMPVAR_STATIC_PROP) \ - _(2946, ZEND_ASSIGN_POW_SPEC_CONST_TMPVAR_STATIC_PROP) \ - _(2950, ZEND_ASSIGN_POW_SPEC_CONST_UNUSED_STATIC_PROP) \ - _(2958, ZEND_ASSIGN_POW_SPEC_TMP_CONST_STATIC_PROP) \ - _(2962, ZEND_ASSIGN_POW_SPEC_TMP_TMPVAR_STATIC_PROP) \ - _(2966, ZEND_ASSIGN_POW_SPEC_TMP_TMPVAR_STATIC_PROP) \ - _(2970, ZEND_ASSIGN_POW_SPEC_TMP_UNUSED_STATIC_PROP) \ - _(2975, ZEND_ASSIGN_POW_SPEC_VAR_CONST) \ - _(2976, ZEND_ASSIGN_POW_SPEC_VAR_CONST_DIM) \ - _(2977, ZEND_ASSIGN_POW_SPEC_VAR_CONST_OBJ) \ - _(2978, ZEND_ASSIGN_POW_SPEC_VAR_CONST_STATIC_PROP) \ - _(2979, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR) \ - _(2980, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM) \ - _(2981, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ) \ - _(2982, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_STATIC_PROP) \ - _(2983, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR) \ - _(2984, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM) \ - _(2985, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ) \ - _(2986, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_STATIC_PROP) \ - _(2988, ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_DIM) \ - _(2990, ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_STATIC_PROP) \ - _(2991, ZEND_ASSIGN_POW_SPEC_VAR_CV) \ - _(2992, ZEND_ASSIGN_POW_SPEC_VAR_CV_DIM) \ - _(2993, ZEND_ASSIGN_POW_SPEC_VAR_CV_OBJ) \ - _(2997, ZEND_ASSIGN_POW_SPEC_UNUSED_CONST_OBJ) \ - _(3001, ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ) \ - _(3005, ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ) \ - _(3013, ZEND_ASSIGN_POW_SPEC_UNUSED_CV_OBJ) \ - _(3015, ZEND_ASSIGN_POW_SPEC_CV_CONST) \ - _(3016, ZEND_ASSIGN_POW_SPEC_CV_CONST_DIM) \ - _(3017, ZEND_ASSIGN_POW_SPEC_CV_CONST_OBJ) \ - _(3018, ZEND_ASSIGN_POW_SPEC_CV_CONST_STATIC_PROP) \ - _(3019, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR) \ - _(3020, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM) \ - _(3021, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ) \ - _(3022, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_STATIC_PROP) \ - _(3023, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR) \ - _(3024, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM) \ - _(3025, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ) \ - _(3026, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_STATIC_PROP) \ - _(3028, ZEND_ASSIGN_POW_SPEC_CV_UNUSED_DIM) \ - _(3030, ZEND_ASSIGN_POW_SPEC_CV_UNUSED_STATIC_PROP) \ - _(3031, ZEND_ASSIGN_POW_SPEC_CV_CV) \ - _(3032, ZEND_ASSIGN_POW_SPEC_CV_CV_DIM) \ - _(3033, ZEND_ASSIGN_POW_SPEC_CV_CV_OBJ) \ - _(3035, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ - _(3036, ZEND_COALESCE_SPEC_CONST) \ - _(3037, ZEND_COALESCE_SPEC_TMPVAR) \ + _(2933, ZEND_POW_SPEC_CV_TMPVAR) \ + _(2935, ZEND_POW_SPEC_CV_CV) \ + _(2939, ZEND_ASSIGN_POW_SPEC_CONST_CONST_STATIC_PROP) \ + _(2943, ZEND_ASSIGN_POW_SPEC_CONST_TMPVAR_STATIC_PROP) \ + _(2947, ZEND_ASSIGN_POW_SPEC_CONST_TMPVAR_STATIC_PROP) \ + _(2951, ZEND_ASSIGN_POW_SPEC_CONST_UNUSED_STATIC_PROP) \ + _(2959, ZEND_ASSIGN_POW_SPEC_TMP_CONST_STATIC_PROP) \ + _(2963, ZEND_ASSIGN_POW_SPEC_TMP_TMPVAR_STATIC_PROP) \ + _(2967, ZEND_ASSIGN_POW_SPEC_TMP_TMPVAR_STATIC_PROP) \ + _(2971, ZEND_ASSIGN_POW_SPEC_TMP_UNUSED_STATIC_PROP) \ + _(2976, ZEND_ASSIGN_POW_SPEC_VAR_CONST) \ + _(2977, ZEND_ASSIGN_POW_SPEC_VAR_CONST_DIM) \ + _(2978, ZEND_ASSIGN_POW_SPEC_VAR_CONST_OBJ) \ + _(2979, ZEND_ASSIGN_POW_SPEC_VAR_CONST_STATIC_PROP) \ + _(2980, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR) \ + _(2981, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM) \ + _(2982, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ) \ + _(2983, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_STATIC_PROP) \ + _(2984, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR) \ + _(2985, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM) \ + _(2986, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ) \ + _(2987, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_STATIC_PROP) \ + _(2989, ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_DIM) \ + _(2991, ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_STATIC_PROP) \ + _(2992, ZEND_ASSIGN_POW_SPEC_VAR_CV) \ + _(2993, ZEND_ASSIGN_POW_SPEC_VAR_CV_DIM) \ + _(2994, ZEND_ASSIGN_POW_SPEC_VAR_CV_OBJ) \ + _(2998, ZEND_ASSIGN_POW_SPEC_UNUSED_CONST_OBJ) \ + _(3002, ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ) \ + _(3006, ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ) \ + _(3014, ZEND_ASSIGN_POW_SPEC_UNUSED_CV_OBJ) \ + _(3016, ZEND_ASSIGN_POW_SPEC_CV_CONST) \ + _(3017, ZEND_ASSIGN_POW_SPEC_CV_CONST_DIM) \ + _(3018, ZEND_ASSIGN_POW_SPEC_CV_CONST_OBJ) \ + _(3019, ZEND_ASSIGN_POW_SPEC_CV_CONST_STATIC_PROP) \ + _(3020, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR) \ + _(3021, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM) \ + _(3022, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ) \ + _(3023, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_STATIC_PROP) \ + _(3024, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR) \ + _(3025, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM) \ + _(3026, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ) \ + _(3027, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_STATIC_PROP) \ + _(3029, ZEND_ASSIGN_POW_SPEC_CV_UNUSED_DIM) \ + _(3031, ZEND_ASSIGN_POW_SPEC_CV_UNUSED_STATIC_PROP) \ + _(3032, ZEND_ASSIGN_POW_SPEC_CV_CV) \ + _(3033, ZEND_ASSIGN_POW_SPEC_CV_CV_DIM) \ + _(3034, ZEND_ASSIGN_POW_SPEC_CV_CV_OBJ) \ + _(3036, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ + _(3037, ZEND_COALESCE_SPEC_CONST) \ _(3038, ZEND_COALESCE_SPEC_TMPVAR) \ - _(3040, ZEND_COALESCE_SPEC_CV) \ - _(3041, ZEND_SPACESHIP_SPEC_CONST_CONST) \ - _(3042, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ + _(3039, ZEND_COALESCE_SPEC_TMPVAR) \ + _(3041, ZEND_COALESCE_SPEC_CV) \ + _(3042, ZEND_SPACESHIP_SPEC_CONST_CONST) \ _(3043, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ - _(3045, ZEND_SPACESHIP_SPEC_CONST_CV) \ - _(3046, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ - _(3047, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(3044, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ + _(3046, ZEND_SPACESHIP_SPEC_CONST_CV) \ + _(3047, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ _(3048, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(3050, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(3051, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ - _(3052, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(3049, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(3051, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(3052, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ _(3053, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(3055, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(3061, ZEND_SPACESHIP_SPEC_CV_CONST) \ - _(3062, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ + _(3054, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(3056, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(3062, ZEND_SPACESHIP_SPEC_CV_CONST) \ _(3063, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ - _(3065, ZEND_SPACESHIP_SPEC_CV_CV) \ - _(3066, ZEND_DECLARE_ANON_CLASS_SPEC) \ - _(3067, ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_CONST_CONST) \ - _(3068, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_CONST) \ - _(3070, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_VAR) \ - _(3071, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_UNUSED) \ - _(3073, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST) \ - _(3075, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR) \ - _(3076, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_UNUSED) \ - _(3078, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST) \ - _(3080, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR) \ - _(3081, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_UNUSED) \ - _(3088, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_CONST) \ - _(3090, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_VAR) \ - _(3091, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_UNUSED) \ - _(3093, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_CONST) \ - _(3095, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_VAR) \ - _(3096, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_UNUSED) \ - _(3098, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_CONST) \ - _(3100, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_VAR) \ - _(3101, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_UNUSED) \ - _(3103, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_CONST) \ - _(3105, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_VAR) \ - _(3106, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_UNUSED) \ - _(3113, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_CONST) \ - _(3115, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_VAR) \ - _(3116, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_UNUSED) \ - _(3118, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_CONST) \ - _(3120, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_VAR) \ - _(3121, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_UNUSED) \ - _(3123, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_CONST) \ - _(3125, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_VAR) \ - _(3126, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_UNUSED) \ - _(3128, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_CONST) \ - _(3130, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_VAR) \ - _(3131, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_UNUSED) \ - _(3138, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_CONST) \ - _(3140, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_VAR) \ - _(3141, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_UNUSED) \ - _(3143, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_CONST) \ - _(3145, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_VAR) \ - _(3146, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_UNUSED) \ - _(3148, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_CONST) \ - _(3150, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_VAR) \ - _(3151, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_UNUSED) \ - _(3153, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_CONST) \ - _(3155, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_VAR) \ - _(3156, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_UNUSED) \ - _(3163, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_CONST) \ - _(3165, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_VAR) \ - _(3166, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_UNUSED) \ - _(3168, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_CONST) \ - _(3170, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_VAR) \ - _(3171, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_UNUSED) \ - _(3173, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_CONST) \ - _(3175, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_VAR) \ - _(3176, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ - _(3178, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_CONST) \ - _(3180, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_VAR) \ - _(3181, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ - _(3188, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_CONST) \ - _(3190, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_VAR) \ - _(3191, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_UNUSED) \ - _(3193, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_CONST) \ - _(3195, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_VAR) \ - _(3196, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_UNUSED) \ - _(3198, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_CONST) \ - _(3200, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_VAR) \ - _(3201, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_UNUSED) \ - _(3203, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_CONST) \ - _(3205, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_VAR) \ - _(3206, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_UNUSED) \ - _(3213, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_CONST) \ - _(3215, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_VAR) \ - _(3216, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_UNUSED) \ - _(3218, ZEND_UNSET_STATIC_PROP_SPEC_CONST_CONST) \ - _(3220, ZEND_UNSET_STATIC_PROP_SPEC_CONST_VAR) \ - _(3221, ZEND_UNSET_STATIC_PROP_SPEC_CONST_UNUSED) \ - _(3223, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_CONST) \ - _(3225, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR) \ - _(3226, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ - _(3228, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_CONST) \ - _(3230, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR) \ - _(3231, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ - _(3238, ZEND_UNSET_STATIC_PROP_SPEC_CV_CONST) \ - _(3240, ZEND_UNSET_STATIC_PROP_SPEC_CV_VAR) \ - _(3241, ZEND_UNSET_STATIC_PROP_SPEC_CV_UNUSED) \ - _(3243, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ - _(3244, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ - _(3246, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ - _(3247, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ - _(3249, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ - _(3250, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \ - _(3251, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ - _(3252, ZEND_SEND_FUNC_ARG_SPEC_VAR) \ - _(3253, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ - _(3254, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ - _(3255, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(3064, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ + _(3066, ZEND_SPACESHIP_SPEC_CV_CV) \ + _(3067, ZEND_DECLARE_ANON_CLASS_SPEC) \ + _(3068, ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_CONST_CONST) \ + _(3069, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_CONST) \ + _(3071, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_VAR) \ + _(3072, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_UNUSED) \ + _(3074, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST) \ + _(3076, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR) \ + _(3077, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_UNUSED) \ + _(3079, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST) \ + _(3081, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR) \ + _(3082, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_UNUSED) \ + _(3089, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_CONST) \ + _(3091, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_VAR) \ + _(3092, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_UNUSED) \ + _(3094, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_CONST) \ + _(3096, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_VAR) \ + _(3097, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_UNUSED) \ + _(3099, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_CONST) \ + _(3101, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_VAR) \ + _(3102, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_UNUSED) \ + _(3104, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_CONST) \ + _(3106, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_VAR) \ + _(3107, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_UNUSED) \ + _(3114, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_CONST) \ + _(3116, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_VAR) \ + _(3117, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_UNUSED) \ + _(3119, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_CONST) \ + _(3121, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_VAR) \ + _(3122, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_UNUSED) \ + _(3124, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_CONST) \ + _(3126, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_VAR) \ + _(3127, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_UNUSED) \ + _(3129, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_CONST) \ + _(3131, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_VAR) \ + _(3132, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_UNUSED) \ + _(3139, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_CONST) \ + _(3141, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_VAR) \ + _(3142, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_UNUSED) \ + _(3144, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_CONST) \ + _(3146, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_VAR) \ + _(3147, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_UNUSED) \ + _(3149, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_CONST) \ + _(3151, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_VAR) \ + _(3152, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_UNUSED) \ + _(3154, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_CONST) \ + _(3156, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_VAR) \ + _(3157, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_UNUSED) \ + _(3164, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_CONST) \ + _(3166, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_VAR) \ + _(3167, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_UNUSED) \ + _(3169, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_CONST) \ + _(3171, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_VAR) \ + _(3172, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_UNUSED) \ + _(3174, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_CONST) \ + _(3176, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_VAR) \ + _(3177, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ + _(3179, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_CONST) \ + _(3181, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_VAR) \ + _(3182, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ + _(3189, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_CONST) \ + _(3191, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_VAR) \ + _(3192, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_UNUSED) \ + _(3194, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_CONST) \ + _(3196, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_VAR) \ + _(3197, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_UNUSED) \ + _(3199, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_CONST) \ + _(3201, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_VAR) \ + _(3202, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_UNUSED) \ + _(3204, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_CONST) \ + _(3206, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_VAR) \ + _(3207, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_UNUSED) \ + _(3214, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_CONST) \ + _(3216, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_VAR) \ + _(3217, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_UNUSED) \ + _(3219, ZEND_UNSET_STATIC_PROP_SPEC_CONST_CONST) \ + _(3221, ZEND_UNSET_STATIC_PROP_SPEC_CONST_VAR) \ + _(3222, ZEND_UNSET_STATIC_PROP_SPEC_CONST_UNUSED) \ + _(3224, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_CONST) \ + _(3226, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR) \ + _(3227, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ + _(3229, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_CONST) \ + _(3231, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR) \ + _(3232, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ + _(3239, ZEND_UNSET_STATIC_PROP_SPEC_CV_CONST) \ + _(3241, ZEND_UNSET_STATIC_PROP_SPEC_CV_VAR) \ + _(3242, ZEND_UNSET_STATIC_PROP_SPEC_CV_UNUSED) \ + _(3244, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ + _(3245, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ + _(3247, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ + _(3248, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ + _(3250, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ + _(3251, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \ + _(3252, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ + _(3253, ZEND_SEND_FUNC_ARG_SPEC_VAR) \ + _(3254, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ + _(3255, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ _(3256, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(3258, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(3259, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ - _(3260, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(3257, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(3259, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(3260, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ _(3261, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(3263, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(3264, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ - _(3265, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ - _(3266, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ - _(3268, ZEND_IN_ARRAY_SPEC_CV_CONST) \ - _(3269, ZEND_COUNT_SPEC_CONST_UNUSED) \ - _(3270, ZEND_COUNT_SPEC_TMP_UNUSED) \ - _(3271, ZEND_COUNT_SPEC_VAR_UNUSED) \ - _(3273, ZEND_COUNT_SPEC_CV_UNUSED) \ - _(3274, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ - _(3275, ZEND_GET_CLASS_SPEC_TMP_UNUSED) \ - _(3276, ZEND_GET_CLASS_SPEC_VAR_UNUSED) \ - _(3277, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ - _(3278, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ - _(3279, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ - _(3280, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ - _(3281, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ - _(3282, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ - _(3284, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ - _(3285, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ - _(3286, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ - _(3289, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ - _(3291, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ - _(3292, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ - _(3293, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ - _(3294, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ - _(3295, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ + _(3262, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(3264, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(3265, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ + _(3266, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ + _(3267, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ + _(3269, ZEND_IN_ARRAY_SPEC_CV_CONST) \ + _(3270, ZEND_COUNT_SPEC_CONST_UNUSED) \ + _(3271, ZEND_COUNT_SPEC_TMP_UNUSED) \ + _(3272, ZEND_COUNT_SPEC_VAR_UNUSED) \ + _(3274, ZEND_COUNT_SPEC_CV_UNUSED) \ + _(3275, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ + _(3276, ZEND_GET_CLASS_SPEC_TMP_UNUSED) \ + _(3277, ZEND_GET_CLASS_SPEC_VAR_UNUSED) \ + _(3278, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ + _(3279, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ + _(3280, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ + _(3281, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ + _(3282, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ + _(3283, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ + _(3285, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ + _(3286, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ + _(3287, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ + _(3290, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ + _(3292, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ + _(3293, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ + _(3294, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ + _(3295, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ _(3296, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ - _(3298, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ - _(3299, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ - _(3300, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ + _(3297, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ + _(3299, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ + _(3300, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ _(3301, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ - _(3303, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ - _(3304, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ - _(3305, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(3302, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ + _(3304, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ + _(3305, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ _(3306, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(3308, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(3309, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ - _(3310, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(3307, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(3309, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(3310, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ _(3311, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(3313, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(3319, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ - _(3320, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ + _(3312, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(3314, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(3320, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ _(3321, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ - _(3323, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ - _(3376, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR) \ - _(3378, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV) \ - _(3381, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ - _(3383, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV) \ - _(3386, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ - _(3388, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV) \ - _(3396, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR) \ - _(3398, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV) \ - _(3401, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR) \ - _(3403, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV) \ - _(3406, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) \ - _(3408, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV) \ - _(3411, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) \ - _(3413, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV) \ - _(3421, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR) \ - _(3423, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV) \ - _(3426, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR) \ - _(3428, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV) \ - _(3431, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR) \ - _(3433, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV) \ - _(3436, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR) \ - _(3438, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV) \ - _(3446, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR) \ - _(3448, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV) \ - _(3449, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST) \ - _(3450, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP) \ - _(3451, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR) \ - _(3453, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV) \ - _(3454, ZEND_ASSIGN_STATIC_PROP_REF_SPEC) \ - _(3455, ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_CONST) \ - _(3457, ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_VAR) \ - _(3458, ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_UNUSED) \ - _(3460, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_CONST) \ - _(3462, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_VAR) \ - _(3463, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ - _(3465, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_CONST) \ - _(3467, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_VAR) \ - _(3468, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ - _(3475, ZEND_PRE_INC_STATIC_PROP_SPEC_CV_CONST) \ - _(3477, ZEND_PRE_INC_STATIC_PROP_SPEC_CV_VAR) \ - _(3478, ZEND_PRE_INC_STATIC_PROP_SPEC_CV_UNUSED) \ - _(3480, ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_CONST) \ - _(3482, ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_VAR) \ - _(3483, ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_UNUSED) \ - _(3485, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_CONST) \ - _(3487, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_VAR) \ - _(3488, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ - _(3490, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_CONST) \ - _(3492, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_VAR) \ - _(3493, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ - _(3500, ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_CONST) \ - _(3502, ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_VAR) \ - _(3503, ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_UNUSED) \ - _(3505, ZEND_POST_INC_STATIC_PROP_SPEC_CONST_CONST) \ - _(3507, ZEND_POST_INC_STATIC_PROP_SPEC_CONST_VAR) \ - _(3508, ZEND_POST_INC_STATIC_PROP_SPEC_CONST_UNUSED) \ - _(3510, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_CONST) \ - _(3512, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_VAR) \ - _(3513, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ - _(3515, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_CONST) \ - _(3517, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_VAR) \ - _(3518, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ - _(3525, ZEND_POST_INC_STATIC_PROP_SPEC_CV_CONST) \ - _(3527, ZEND_POST_INC_STATIC_PROP_SPEC_CV_VAR) \ - _(3528, ZEND_POST_INC_STATIC_PROP_SPEC_CV_UNUSED) \ - _(3530, ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_CONST) \ - _(3532, ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_VAR) \ - _(3533, ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_UNUSED) \ - _(3535, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_CONST) \ - _(3537, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_VAR) \ - _(3538, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ - _(3540, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_CONST) \ - _(3542, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_VAR) \ - _(3543, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ - _(3550, ZEND_POST_DEC_STATIC_PROP_SPEC_CV_CONST) \ - _(3552, ZEND_POST_DEC_STATIC_PROP_SPEC_CV_VAR) \ - _(3553, ZEND_POST_DEC_STATIC_PROP_SPEC_CV_UNUSED) \ - _(3555, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ - _(3556, ZEND_JMP_FORWARD_SPEC) \ - _(3562, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3563, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3322, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ + _(3324, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ + _(3377, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR) \ + _(3379, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV) \ + _(3382, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ + _(3384, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV) \ + _(3387, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ + _(3389, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV) \ + _(3397, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR) \ + _(3399, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV) \ + _(3402, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR) \ + _(3404, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV) \ + _(3407, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) \ + _(3409, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV) \ + _(3412, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) \ + _(3414, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV) \ + _(3422, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR) \ + _(3424, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV) \ + _(3427, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR) \ + _(3429, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV) \ + _(3432, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR) \ + _(3434, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV) \ + _(3437, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR) \ + _(3439, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV) \ + _(3447, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR) \ + _(3449, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV) \ + _(3450, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST) \ + _(3451, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP) \ + _(3452, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR) \ + _(3454, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV) \ + _(3455, ZEND_ASSIGN_STATIC_PROP_REF_SPEC) \ + _(3456, ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_CONST) \ + _(3458, ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_VAR) \ + _(3459, ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_UNUSED) \ + _(3461, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_CONST) \ + _(3463, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_VAR) \ + _(3464, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ + _(3466, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_CONST) \ + _(3468, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_VAR) \ + _(3469, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ + _(3476, ZEND_PRE_INC_STATIC_PROP_SPEC_CV_CONST) \ + _(3478, ZEND_PRE_INC_STATIC_PROP_SPEC_CV_VAR) \ + _(3479, ZEND_PRE_INC_STATIC_PROP_SPEC_CV_UNUSED) \ + _(3481, ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_CONST) \ + _(3483, ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_VAR) \ + _(3484, ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_UNUSED) \ + _(3486, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_CONST) \ + _(3488, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_VAR) \ + _(3489, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ + _(3491, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_CONST) \ + _(3493, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_VAR) \ + _(3494, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ + _(3501, ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_CONST) \ + _(3503, ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_VAR) \ + _(3504, ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_UNUSED) \ + _(3506, ZEND_POST_INC_STATIC_PROP_SPEC_CONST_CONST) \ + _(3508, ZEND_POST_INC_STATIC_PROP_SPEC_CONST_VAR) \ + _(3509, ZEND_POST_INC_STATIC_PROP_SPEC_CONST_UNUSED) \ + _(3511, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_CONST) \ + _(3513, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_VAR) \ + _(3514, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ + _(3516, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_CONST) \ + _(3518, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_VAR) \ + _(3519, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ + _(3526, ZEND_POST_INC_STATIC_PROP_SPEC_CV_CONST) \ + _(3528, ZEND_POST_INC_STATIC_PROP_SPEC_CV_VAR) \ + _(3529, ZEND_POST_INC_STATIC_PROP_SPEC_CV_UNUSED) \ + _(3531, ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_CONST) \ + _(3533, ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_VAR) \ + _(3534, ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_UNUSED) \ + _(3536, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_CONST) \ + _(3538, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_VAR) \ + _(3539, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ + _(3541, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_CONST) \ + _(3543, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_VAR) \ + _(3544, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ + _(3551, ZEND_POST_DEC_STATIC_PROP_SPEC_CV_CONST) \ + _(3553, ZEND_POST_DEC_STATIC_PROP_SPEC_CV_VAR) \ + _(3554, ZEND_POST_DEC_STATIC_PROP_SPEC_CV_UNUSED) \ + _(3556, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ + _(3557, ZEND_JMP_FORWARD_SPEC) \ + _(3563, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3564, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3566, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3567, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3568, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3565, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3567, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3568, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3569, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3571, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3577, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3578, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3570, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3572, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3578, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3579, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3581, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3587, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(3588, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3580, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3582, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3588, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(3589, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3591, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3592, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(3593, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3590, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3592, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3593, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(3594, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3596, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3602, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(3603, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3595, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3597, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3603, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(3604, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3606, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3612, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3613, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3605, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3607, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3613, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3614, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3616, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3617, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3618, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3615, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3617, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3618, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3619, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3621, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3627, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3628, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3620, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3622, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3628, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3629, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3631, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3633, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(3630, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3632, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3634, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(3636, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(3637, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3638, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3635, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(3637, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(3638, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3639, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3641, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3642, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3643, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3640, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3642, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3643, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3644, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3646, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3652, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3653, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3645, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3647, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3653, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3654, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3656, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3658, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(3655, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3657, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(3659, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(3661, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(3662, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(3663, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3660, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(3662, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(3663, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(3664, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3666, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3667, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(3668, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3665, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3667, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3668, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(3669, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3671, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3677, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(3678, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3670, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3672, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3678, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(3679, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3681, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3683, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3680, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3682, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(3684, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3686, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3687, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3688, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3685, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3687, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3688, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3689, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3691, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3692, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3693, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3690, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3692, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3693, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3694, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3696, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3702, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3703, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3695, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3697, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3703, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3704, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3706, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3712, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3713, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3705, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3707, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3713, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3714, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3716, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3717, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3718, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3715, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3717, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3718, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3719, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3721, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3727, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3728, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3720, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3722, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3728, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3729, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3731, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3737, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(3738, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3730, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3732, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3738, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(3739, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3741, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3742, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(3743, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3740, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3742, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3743, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(3744, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3746, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3752, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(3753, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3745, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3747, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3753, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(3754, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3756, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3762, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3763, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3755, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3757, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3763, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3764, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3766, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3767, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3768, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3765, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3767, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3768, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3769, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3771, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3777, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3778, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3770, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3772, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3778, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3779, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3781, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3797, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3798, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3799, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3800, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3801, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3802, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3803, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3804, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3805, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3809, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3810, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3811, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3812, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3813, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3814, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3815, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3816, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3817, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3818, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3819, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3820, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3824, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3825, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3826, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3845, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3849, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3850, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3854, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3855, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3856, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3872, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3873, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3874, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3875, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3876, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3877, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3878, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3879, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3880, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3884, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3885, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3886, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3887, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3888, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3889, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3890, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3891, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3892, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3893, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3894, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3895, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3899, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3900, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3901, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3920, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3924, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3925, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3929, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3930, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3931, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3947, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3948, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3949, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3950, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3951, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3952, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3953, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3954, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3955, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3959, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3960, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3961, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3962, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3963, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3964, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3965, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3966, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3967, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3968, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3969, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3970, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3974, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3975, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3976, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3999, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4000, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4004, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4005, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4006, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4022, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(4023, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4024, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4025, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4026, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4027, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4028, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4029, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4030, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4034, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4035, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4036, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4037, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(4038, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4039, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4040, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4041, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4042, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4043, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4044, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4045, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4049, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4050, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4051, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(4068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4074, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4075, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4079, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4080, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4081, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4085, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(4086, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4087, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4088, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(4089, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4090, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4094, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(4095, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4096, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4097, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(4098, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4099, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4100, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4101, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4102, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4103, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4104, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4105, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4109, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4110, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4111, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4112, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(4113, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4114, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4115, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4116, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4117, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4118, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4119, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4120, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4124, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4125, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4126, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4142, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(4143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4154, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4160, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(4161, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4162, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4163, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(4164, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4165, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4169, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(4170, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4171, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4172, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(4173, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4174, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4175, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4176, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4177, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4178, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4179, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4180, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4184, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4185, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4186, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4187, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(4188, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4189, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4190, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4191, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4192, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4193, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4194, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4195, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4199, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4200, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4201, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4217, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(4218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4229, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4235, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(4236, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4237, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4238, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(4239, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4240, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4244, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(4245, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4246, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4247, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(4248, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4249, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4250, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4251, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4252, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4253, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4254, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4255, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4259, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4260, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4261, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4262, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(4263, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4264, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4265, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4266, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4267, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4268, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4269, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4270, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(4293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4310, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(4311, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4312, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4313, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(4314, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4315, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4319, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(4320, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4321, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4322, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(4323, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4324, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4325, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4326, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4327, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4328, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4329, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4330, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4334, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4335, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4336, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4337, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(4338, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4339, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4340, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4341, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4342, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4343, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4344, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4345, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(4368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4382, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \ - _(4383, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \ - _(4384, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \ - _(4385, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED) \ - _(4386, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \ - _(4387, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \ - _(4388, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \ - _(4389, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \ - _(4390, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \ - _(4391, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED) \ - _(4392, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \ - _(4393, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \ - _(4394, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \ - _(4395, ZEND_POST_INC_LONG_SPEC_TMPVARCV) \ - _(4396, ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \ - _(4397, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \ - _(4398, ZEND_POST_DEC_LONG_SPEC_TMPVARCV) \ - _(4399, ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \ - _(4400, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(4401, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3780, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3782, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3798, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3799, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3800, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3801, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3802, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3803, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3804, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3805, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3806, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3810, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3811, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3812, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3813, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3814, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3815, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3816, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3817, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3818, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3819, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3820, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3821, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3825, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3826, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3827, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3845, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3849, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3850, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3851, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3855, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3856, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3857, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3873, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3874, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3875, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3876, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3877, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3878, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3879, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3880, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3881, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3885, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3886, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3887, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3888, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3889, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3890, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3891, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3892, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3893, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3894, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3895, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3896, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3900, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3901, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3902, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3920, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3924, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3925, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3926, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3930, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3931, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3932, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3948, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3949, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3950, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3951, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3952, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3953, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3954, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3955, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3956, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3960, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3961, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3962, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3963, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3964, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3965, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3966, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3967, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3968, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3969, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3970, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3971, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3975, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3976, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3977, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3999, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4000, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4001, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4005, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4006, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4007, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4023, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(4024, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4025, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4026, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4027, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4028, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4029, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4030, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4031, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4035, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4036, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4037, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4038, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(4039, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4040, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4041, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4042, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4043, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4044, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4045, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4046, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4050, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4051, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4052, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(4069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4074, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4075, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4076, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4080, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4081, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4082, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4086, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(4087, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4088, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4089, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(4090, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4091, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4095, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(4096, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4097, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4098, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(4099, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4100, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4101, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4102, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4103, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4104, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4105, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4106, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4110, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4111, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4112, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4113, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(4114, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4115, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4116, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4117, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4118, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4119, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4120, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4121, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4125, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4126, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4127, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(4144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4161, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(4162, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4163, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4164, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(4165, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4166, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4170, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(4171, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4172, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4173, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(4174, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4175, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4176, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4177, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4178, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4179, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4180, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4181, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4185, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4186, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4187, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4188, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(4189, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4190, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4191, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4192, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4193, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4194, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4195, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4196, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4200, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4201, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4202, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(4219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4236, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(4237, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4238, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4239, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(4240, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4241, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4245, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(4246, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4247, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4248, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(4249, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4250, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4251, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4252, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4253, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4254, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4255, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4256, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4260, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4261, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4262, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4263, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(4264, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4265, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4266, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4267, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4268, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4269, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4270, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4271, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4277, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(4294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4311, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(4312, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4313, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4314, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(4315, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4316, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4320, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(4321, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4322, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4323, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(4324, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4325, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4326, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4327, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4328, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4329, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4330, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4331, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4335, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4336, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4337, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4338, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(4339, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4340, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4341, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4342, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4343, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4344, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4345, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4346, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4352, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(4369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4383, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \ + _(4384, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \ + _(4385, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \ + _(4386, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED) \ + _(4387, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \ + _(4388, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \ + _(4389, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \ + _(4390, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \ + _(4391, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \ + _(4392, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED) \ + _(4393, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \ + _(4394, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \ + _(4395, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \ + _(4396, ZEND_POST_INC_LONG_SPEC_TMPVARCV) \ + _(4397, ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \ + _(4398, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \ + _(4399, ZEND_POST_DEC_LONG_SPEC_TMPVARCV) \ + _(4400, ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \ + _(4401, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ _(4402, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(4404, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(4405, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(4406, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(4403, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(4405, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(4406, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ _(4407, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(4409, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(4411, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(4408, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(4410, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ _(4412, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(4414, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(4415, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(4416, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(4413, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(4415, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(4416, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ _(4417, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(4419, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(4420, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(4421, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(4418, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(4420, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(4421, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ _(4422, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(4424, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(4430, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(4431, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(4423, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(4425, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(4431, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ _(4432, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(4434, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(4437, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(4439, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(4442, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \ - _(4444, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \ - _(4445, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(4446, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(4447, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(4448, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(4448+1, ZEND_NULL) + _(4433, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(4435, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(4438, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(4440, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(4443, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \ + _(4445, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \ + _(4446, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(4447, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(4448, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(4449, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(4449+1, ZEND_NULL) diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index 3e564782dcaba..f92d1ef3d478e 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -169,7 +169,7 @@ static const char *zend_vm_opcodes_names[208] = { "ZEND_DECLARE_CONST", NULL, "ZEND_DECLARE_INHERITED_CLASS_DELAYED", - NULL, + "ZEND_VERIFY_VARIANCE", "ZEND_ASSIGN_DIM", "ZEND_ISSET_ISEMPTY_PROP_OBJ", "ZEND_HANDLE_EXCEPTION", @@ -380,7 +380,7 @@ static uint32_t zend_vm_opcodes_flags[208] = { 0x00000303, 0x00000000, 0x00000303, - 0x00000000, + 0x00000103, 0x00006701, 0x00060757, 0x00000000, diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h index 65efc4881652f..abe95f743e49c 100644 --- a/Zend/zend_vm_opcodes.h +++ b/Zend/zend_vm_opcodes.h @@ -221,6 +221,7 @@ END_EXTERN_C() #define ZEND_YIELD_FROM 142 #define ZEND_DECLARE_CONST 143 #define ZEND_DECLARE_INHERITED_CLASS_DELAYED 145 +#define ZEND_VERIFY_VARIANCE 146 #define ZEND_ASSIGN_DIM 147 #define ZEND_ISSET_ISEMPTY_PROP_OBJ 148 #define ZEND_HANDLE_EXCEPTION 149 From e6e03215045b3ec893bacba630c591161bafaef2 Mon Sep 17 00:00:00 2001 From: Levi Morrison Date: Fri, 4 Jan 2019 09:46:56 -0700 Subject: [PATCH 02/19] Extract _get_parent_class_name This should probably be moved somewhere else and renamed. --- Zend/zend_inheritance.c | 37 +++++++++++++++++++++---------------- 1 file changed, 21 insertions(+), 16 deletions(-) diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index 10f04af7057ad..0085724f81505 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -184,29 +184,34 @@ static zend_always_inline zend_bool zend_iterable_compatibility_check(zend_arg_i } /* }}} */ +/* todo: this is probably useful elsewhere too */ +/* caller is responsible for adding any necessary refcount */ +static zend_string *_get_parent_class_name(zend_class_entry *ce) +{ /* {{{ */ + zend_string *pname; + + if (ce->ce_flags & ZEND_ACC_LINKED) { + ZEND_ASSERT(ce->parent); + pname = ce->parent->name; + } else { + pname = ce->parent_name; + } + + /* If there is a parent, it must have a name */ + ZEND_ASSERT(pname); + return pname; +}/* }}} */ + static zend_string *_resolve_parent_and_self(const zend_function *fe, zend_string *name) -{ +{ /* {{{ */ zend_class_entry *ce = fe->common.scope; /* if there isn't a class then we shouldn't be resolving parent and self */ ZEND_ASSERT(fe->common.scope); switch (zend_get_class_fetch_type(name)) { case ZEND_FETCH_CLASS_PARENT: - name = NULL; - if (ce->ce_flags & ZEND_ACC_LINKED) { - if (ce->parent && ce->parent->name) { - name = ce->parent->name; - } - } else if (ce->parent_name) { - name = ce->parent_name; - } - if (name == NULL) { - zend_error_noreturn(E_COMPILE_ERROR, - "Cannot use parent as type constraint in %s::%s() because %s does not have a parent type", - ZEND_FN_SCOPE_NAME(fe), ZSTR_VAL(fe->common.function_name), - ZEND_FN_SCOPE_NAME(fe)); - } + name = _get_parent_class_name(ce); break; case ZEND_FETCH_CLASS_SELF: @@ -227,7 +232,7 @@ zend_string *_resolve_parent_and_self(const zend_function *fe, zend_string *name } return zend_string_copy(name); -} +} /* }}} */ typedef enum { CONTRAVARIANT = -1, From fd3faa3f2c6d21ed56e402c127487e14c1ae8cbe Mon Sep 17 00:00:00 2001 From: Levi Morrison Date: Wed, 9 Jan 2019 11:35:57 -0700 Subject: [PATCH 03/19] Improve variance implementation This work is based off Nikita's review. Notably: - Implement contravariance in terms of covariance - Improve support for non-consecutive type decls - Adds _inheritance_status enum --- Zend/tests/bug76451.phpt | 8 +- ...nconsecutive_variant_declarations_001.phpt | 20 ++ ...nconsecutive_variant_declarations_002.phpt | 21 ++ ...defined_type_during_variance_check_04.phpt | 1 - Zend/zend_compile.c | 25 +-- Zend/zend_inheritance.c | 183 ++++++++---------- Zend/zend_vm_def.h | 9 +- Zend/zend_vm_execute.h | 9 +- 8 files changed, 143 insertions(+), 133 deletions(-) create mode 100644 Zend/tests/type_declarations/nonconsecutive_variant_declarations_001.phpt create mode 100644 Zend/tests/type_declarations/nonconsecutive_variant_declarations_002.phpt diff --git a/Zend/tests/bug76451.phpt b/Zend/tests/bug76451.phpt index 493ae90270d28..243056bdd6687 100644 --- a/Zend/tests/bug76451.phpt +++ b/Zend/tests/bug76451.phpt @@ -1,11 +1,5 @@ --TEST-- -Aliases during inheritance type checks affected by opcache ---INI-- -opcache.enable=1 -opcache.enable_cli=1 -opcache.optimization_level=-1 ---SKIPIF-- - +Aliases during inheritance type checks (affected by opcache) --FILE-- m()); +?> +--EXPECT-- +hiB diff --git a/Zend/tests/type_declarations/nonconsecutive_variant_declarations_002.phpt b/Zend/tests/type_declarations/nonconsecutive_variant_declarations_002.phpt new file mode 100644 index 0000000000000..7e17750ae062e --- /dev/null +++ b/Zend/tests/type_declarations/nonconsecutive_variant_declarations_002.phpt @@ -0,0 +1,21 @@ +--TEST-- +non-consecutive type decls are still checked for variance +--FILE-- +m()); +?> +--EXPECTF-- +hi +Fatal error: Declaration of B::m(): stdClass must be compatible with A::m(): A in %s on line %d diff --git a/Zend/tests/typehints/undefined_type_during_variance_check_04.phpt b/Zend/tests/typehints/undefined_type_during_variance_check_04.phpt index f7c0e3042aec4..dce0a82243054 100644 --- a/Zend/tests/typehints/undefined_type_during_variance_check_04.phpt +++ b/Zend/tests/typehints/undefined_type_during_variance_check_04.phpt @@ -13,4 +13,3 @@ class Y implements X { ?> --EXPECTF-- Fatal error: Declaration of Y::m(UndefinedA $z) must be compatible with X::m(stdClass $z) in %s on line %d - diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index d19b3da65ff4f..8df5fa44f3c04 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -8186,8 +8186,9 @@ static zend_bool _is_not_decl_stmt(zend_ast *ast) { if (ast) { /* todo: what else should be considered a decl stmt? */ switch (ast->kind) { - case ZEND_AST_FUNC_DECL: case ZEND_AST_CLASS: + case ZEND_AST_CONST_DECL: + case ZEND_AST_FUNC_DECL: return 0; default: @@ -8215,11 +8216,10 @@ void zend_compile_top_stmt(zend_ast *ast) /* {{{ */ } if (ast->kind == ZEND_AST_STMT_LIST) { - zend_ast_list *list = zend_ast_get_list(ast); - zend_ast **begin = list->child; - zend_ast **end = begin + list->children; + zend_ast_list *const list = zend_ast_get_list(ast); + zend_ast ** const begin = list->child; + zend_ast ** const end = begin + list->children; zend_ast **first_decl = _ast_find(begin, end, &_is_type_decl); - zend_ast **last_decl = _ast_find(first_decl, end, &_is_not_decl_stmt); zend_ast **p; /* Compile opcodes before first type decl */ @@ -8228,7 +8228,8 @@ void zend_compile_top_stmt(zend_ast *ast) /* {{{ */ } /* Compile decl stmts */ - { + while (first_decl != end) { + zend_ast **last_decl = _ast_find(first_decl, end, &_is_not_decl_stmt); HashTable unverified_types; HashTable *prev_unverified_types; _backup_unverified_variance_types(&unverified_types, &prev_unverified_types); @@ -8241,12 +8242,14 @@ void zend_compile_top_stmt(zend_ast *ast) /* {{{ */ zend_hash_destroy(&unverified_types); CG(unverified_types) = prev_unverified_types; - } - /* Compile remainder */ - /* todo: loop to catch any non-consecutive type declarations */ - for (p = last_decl; p < end; ++p) { - zend_compile_top_stmt(*p); + /* There can be non-consecutive type decls, so continue searching */ + first_decl = _ast_find(last_decl, end, &_is_type_decl); + + /* Compile any stmts between the two type decls (or the end) */ + for (p = last_decl; p < first_decl; ++p) { + zend_compile_top_stmt(*p); + } } return; } diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index 0085724f81505..60d1fa3320d5b 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -215,7 +215,7 @@ zend_string *_resolve_parent_and_self(const zend_function *fe, zend_string *name break; case ZEND_FETCH_CLASS_SELF: - name = fe->common.scope->name; + name = ce->name; break; case ZEND_FETCH_CLASS_DEFAULT: @@ -235,43 +235,20 @@ zend_string *_resolve_parent_and_self(const zend_function *fe, zend_string *name } /* }}} */ typedef enum { - CONTRAVARIANT = -1, - INVARIANT = 0, - COVARIANT = +1, -} _variance; - -static -int _check_zce_variance( - const zend_class_entry *ce1, const zend_class_entry *ce2, - _variance variance) /* {{{ */ -{ - if (ce1 == ce2) return 1; - - switch (variance) { - case INVARIANT: - // todo: does ce1 == ce2 above catch all possible cases? - return 0; - case COVARIANT: - return instanceof_function(ce1, ce2); - case CONTRAVARIANT: - return instanceof_function(ce2, ce1); - - EMPTY_SWITCH_DEFAULT_CASE(); - } -} - -/* This int return is not a boolean, but will often be treated this way. - * * 0 means there is definitely an error. - * * 1 means there are definitely not any errors. - * * -1 means there are no known errors but it is not known to be good - * either (there is not enough information at the moment). - */ + INHERITANCE_UNRESOLVED = -1, + INHERITANCE_ERROR = 0, + INHERITANCE_SUCCESS = 1, +} _inheritance_status; + +/* Parameters are contravariant; return types are covariant. We can rely on + * the fact that they are inverses to improve correctness and simplify code. + * We can implement covariance, and then implement contravariance simply by + * reversing the argument order. */ static -int _check_inherited_arg_info( +_inheritance_status _check_covariance( const zend_function *fe, zend_arg_info *fe_arg_info, - const zend_function *proto, zend_arg_info *proto_arg_info, - _variance variance) /* {{{ */ -{ + const zend_function *proto, zend_arg_info *proto_arg_info) +{ /* {{{ */ zend_type fe_type = fe_arg_info->type; zend_type proto_type = proto_arg_info->type; zend_long fe_type_code = ZEND_TYPE_CODE(fe_type); @@ -280,90 +257,78 @@ int _check_inherited_arg_info( ZEND_ASSERT(ZEND_TYPE_IS_SET(fe_type)); ZEND_ASSERT(ZEND_TYPE_IS_SET(proto_type)); - if (variance == COVARIANT && ZEND_TYPE_ALLOW_NULL(fe_type) && !ZEND_TYPE_ALLOW_NULL(proto_type)) { - return 0; - } - - /* This introduces BC break described at https://bugs.php.net/bug.php?id=72119 */ - if (variance == CONTRAVARIANT && ZEND_TYPE_ALLOW_NULL(proto_type) && !ZEND_TYPE_ALLOW_NULL(fe_type)) { - return 0; + if (ZEND_TYPE_ALLOW_NULL(fe_type) && !ZEND_TYPE_ALLOW_NULL(proto_type)) { + return INHERITANCE_ERROR; } if (ZEND_TYPE_IS_CLASS(fe_type)) { zend_string *fe_class_name = _resolve_parent_and_self(fe, ZEND_TYPE_NAME(fe_type)); - int code = 1; + _inheritance_status code; if (ZEND_TYPE_IS_CLASS(proto_type)) { zend_string *proto_class_name = _resolve_parent_and_self(proto, ZEND_TYPE_NAME(proto_type)); - if (!zend_string_equals_ci(fe_class_name, proto_class_name)) { + if (zend_string_equals_ci(fe_class_name, proto_class_name)) { + code = INHERITANCE_SUCCESS; + } else { if (fe->common.type == ZEND_USER_FUNCTION) { - zend_class_entry * fe_ce = zend_lookup_class(fe_class_name); - zend_class_entry * proto_ce = zend_lookup_class(proto_class_name); + zend_class_entry *fe_ce = zend_lookup_class(fe_class_name); + zend_class_entry *proto_ce = zend_lookup_class(proto_class_name); if (fe_ce && proto_ce) { - code = _check_zce_variance(fe_ce, proto_ce, variance); + code = instanceof_function(fe_ce, proto_ce) + ? INHERITANCE_SUCCESS + : INHERITANCE_ERROR; } else { - /* The -1 will still be considered "truthy". It means there - * is not enough information at the moment, but there are - * not any known errors either. */ - code = -1; + code = INHERITANCE_UNRESOLVED; } } else { - code = 0; + /* todo: what should this actually do? */ + code = INHERITANCE_ERROR; } } zend_string_release(proto_class_name); - } else if (variance == COVARIANT) { - if (proto_type_code == IS_ITERABLE) { - zend_class_entry * fe_ce = zend_lookup_class(fe_class_name); - code = fe_ce ? instanceof_function(fe_ce, zend_ce_traversable) : -1; - } else if (proto_type_code != IS_OBJECT) { - code = 0; + } else if (proto_type_code == IS_ITERABLE) { + zend_class_entry *fe_ce = zend_lookup_class(fe_class_name); + if (fe_ce) { + code = instanceof_function(fe_ce, zend_ce_traversable) + ? INHERITANCE_SUCCESS + : INHERITANCE_ERROR; + } else { + code = INHERITANCE_UNRESOLVED; } + } else if (proto_type_code == IS_OBJECT) { + code = INHERITANCE_SUCCESS; } else { - code = 0; + code = INHERITANCE_ERROR; } zend_string_release(fe_class_name); return code; } else if (ZEND_TYPE_IS_CLASS(proto_type)) { - if (variance == CONTRAVARIANT) { - if (fe_type_code == IS_ITERABLE) { - zend_string *proto_class_name = - _resolve_parent_and_self(proto, ZEND_TYPE_NAME(proto_type)); - zend_class_entry *proto_ce = zend_lookup_class(proto_class_name); - zend_string_release(proto_class_name); - return proto_ce - ? instanceof_function(proto_ce, zend_ce_traversable) - : -1; - } else if (fe_type_code == IS_OBJECT) { - return 1; - } - } - } else if (fe_type_code == IS_ITERABLE || proto_type_code == IS_ITERABLE) { - return (variance == COVARIANT && fe_type_code == IS_ARRAY) - || (variance == CONTRAVARIANT && proto_type_code == IS_ARRAY); + return INHERITANCE_ERROR; + } else if (proto_type_code == IS_ITERABLE) { + return fe_type_code == IS_ARRAY ? INHERITANCE_SUCCESS : INHERITANCE_ERROR; } else if (fe_type_code == proto_type_code) { - return 1; + return INHERITANCE_SUCCESS; } - return 0; + return INHERITANCE_ERROR; } /* }}} */ static -int _check_inherited_return_type( +_inheritance_status _check_inherited_return_type( const zend_function *fe, zend_arg_info *fe_arg_info, const zend_function *proto, zend_arg_info *proto_arg_info) /* {{{ */ { /* Removing a return type is not valid. */ if (!(fe->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE)) { - return 0; + return INHERITANCE_ERROR; } - return _check_inherited_arg_info(fe, fe_arg_info, proto, proto_arg_info, COVARIANT); + return _check_covariance(fe, fe_arg_info, proto, proto_arg_info); } @@ -373,31 +338,33 @@ static zend_bool _missing_internal_arginfo(zend_function const *fn) } static -int _check_inherited_parameter_type( +_inheritance_status _check_inherited_parameter_type( const zend_function *fe, zend_arg_info *fe_arg_info, const zend_function *proto, zend_arg_info *proto_arg_info) /* {{{ */ { /* by-ref constraints on arguments are invariant */ if (fe_arg_info->pass_by_reference != proto_arg_info->pass_by_reference) { - return 0; + return INHERITANCE_ERROR; } if (!ZEND_TYPE_IS_SET(fe_arg_info->type)) { /* Child with no type is always compatible */ - return 1; + return INHERITANCE_SUCCESS; } if (!ZEND_TYPE_IS_SET(proto_arg_info->type)) { /* Child defines a type, but parent doesn't, violates LSP */ - return 0; + return INHERITANCE_ERROR; } - return _check_inherited_arg_info(fe, fe_arg_info, proto, proto_arg_info, CONTRAVARIANT); + /* CONTRAVARIANT is inverse of COVARIANT, so call with reversed args. */ + return _check_covariance(proto, proto_arg_info, fe, fe_arg_info); } /* }}} */ -static int zend_do_perform_implementation_check(const zend_function *fe, const zend_function *proto) /* {{{ */ +static +_inheritance_status zend_do_perform_implementation_check(const zend_function *fe, const zend_function *proto) /* {{{ */ { uint32_t i, num_args; @@ -406,7 +373,7 @@ static int zend_do_perform_implementation_check(const zend_function *fe, const z * functions because extensions don't always define arg_info. */ if (_missing_internal_arginfo(proto)) { - return 1; + return INHERITANCE_SUCCESS; } /* Checks for constructors only if they are declared in an interface, @@ -415,29 +382,29 @@ static int zend_do_perform_implementation_check(const zend_function *fe, const z if ((fe->common.fn_flags & ZEND_ACC_CTOR) && ((proto->common.scope->ce_flags & ZEND_ACC_INTERFACE) == 0 && (proto->common.fn_flags & ZEND_ACC_ABSTRACT) == 0)) { - return 1; + return INHERITANCE_SUCCESS; } /* If the prototype method is private do not enforce a signature */ if (proto->common.fn_flags & ZEND_ACC_PRIVATE) { - return 1; + return INHERITANCE_SUCCESS; } /* check number of arguments */ if (proto->common.required_num_args < fe->common.required_num_args || proto->common.num_args > fe->common.num_args) { - return 0; + return INHERITANCE_ERROR; } /* by-ref constraints on return values are covariant */ if ((proto->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) && !(fe->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)) { - return 0; + return INHERITANCE_ERROR; } if ((proto->common.fn_flags & ZEND_ACC_VARIADIC) && !(fe->common.fn_flags & ZEND_ACC_VARIADIC)) { - return 0; + return INHERITANCE_ERROR; } /* For variadic functions any additional (optional) arguments that were added must be @@ -462,7 +429,7 @@ static int zend_do_perform_implementation_check(const zend_function *fe, const z : &proto->common.arg_info[proto->common.num_args]; if (!_check_inherited_parameter_type(fe, fe_arg_info, proto, proto_arg_info)) { - return 0; + return INHERITANCE_ERROR; } } @@ -472,7 +439,7 @@ static int zend_do_perform_implementation_check(const zend_function *fe, const z return _check_inherited_return_type( fe, fe->common.arg_info - 1, proto, proto->common.arg_info - 1); } - return 1; + return INHERITANCE_SUCCESS; } /* }}} */ @@ -723,7 +690,7 @@ static void do_inheritance_check_on_method(zend_function *child, zend_function * ZEND_FN_SCOPE_NAME(child), ZSTR_VAL(child->common.function_name), zend_visibility_string(parent_flags), ZEND_FN_SCOPE_NAME(parent), (parent_flags&ZEND_ACC_PUBLIC) ? "" : " or weaker"); } - if (UNEXPECTED(!zend_do_perform_implementation_check(child, parent))) { + if (UNEXPECTED(zend_do_perform_implementation_check(child, parent)) == INHERITANCE_ERROR) { int error_level; const char *error_verb; zend_string *method_prototype = zend_get_function_declaration(parent); @@ -1472,7 +1439,7 @@ static void zend_add_trait_method(zend_class_entry *ce, const char *name, zend_s if ((existing_fn = zend_hash_find_ptr(*overridden, key)) != NULL) { if (existing_fn->common.fn_flags & ZEND_ACC_ABSTRACT) { /* Make sure the trait method is compatible with previosly declared abstract method */ - if (UNEXPECTED(!zend_do_perform_implementation_check(fn, existing_fn))) { + if (UNEXPECTED(zend_do_perform_implementation_check(fn, existing_fn) == INHERITANCE_ERROR)) { zend_error_noreturn(E_COMPILE_ERROR, "Declaration of %s must be compatible with %s", ZSTR_VAL(zend_get_function_declaration(fn)), ZSTR_VAL(zend_get_function_declaration(existing_fn))); @@ -1480,7 +1447,7 @@ static void zend_add_trait_method(zend_class_entry *ce, const char *name, zend_s } if (fn->common.fn_flags & ZEND_ACC_ABSTRACT) { /* Make sure the abstract declaration is compatible with previous declaration */ - if (UNEXPECTED(!zend_do_perform_implementation_check(existing_fn, fn))) { + if (UNEXPECTED(zend_do_perform_implementation_check(existing_fn, fn) == INHERITANCE_ERROR)) { zend_error_noreturn(E_COMPILE_ERROR, "Declaration of %s must be compatible with %s", ZSTR_VAL(zend_get_function_declaration(existing_fn)), ZSTR_VAL(zend_get_function_declaration(fn))); @@ -1497,14 +1464,14 @@ static void zend_add_trait_method(zend_class_entry *ce, const char *name, zend_s } else if (existing_fn->common.fn_flags & ZEND_ACC_ABSTRACT && (existing_fn->common.scope->ce_flags & ZEND_ACC_INTERFACE) == 0) { /* Make sure the trait method is compatible with previosly declared abstract method */ - if (UNEXPECTED(!zend_do_perform_implementation_check(fn, existing_fn))) { + if (UNEXPECTED(zend_do_perform_implementation_check(fn, existing_fn) == INHERITANCE_ERROR)) { zend_error_noreturn(E_COMPILE_ERROR, "Declaration of %s must be compatible with %s", ZSTR_VAL(zend_get_function_declaration(fn)), ZSTR_VAL(zend_get_function_declaration(existing_fn))); } } else if (fn->common.fn_flags & ZEND_ACC_ABSTRACT) { /* Make sure the abstract declaration is compatible with previous declaration */ - if (UNEXPECTED(!zend_do_perform_implementation_check(existing_fn, fn))) { + if (UNEXPECTED(zend_do_perform_implementation_check(existing_fn, fn) == INHERITANCE_ERROR)) { zend_error_noreturn(E_COMPILE_ERROR, "Declaration of %s must be compatible with %s", ZSTR_VAL(zend_get_function_declaration(existing_fn)), ZSTR_VAL(zend_get_function_declaration(fn))); @@ -2172,7 +2139,11 @@ static void _inheritance_runtime_error_msg(zend_function *child, zend_function * const char *verb = "should"; ZEND_ASSERT(child && parent); if ((parent->common.fn_flags & ZEND_ACC_ABSTRACT) - || ((parent->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE))) + || ( + (parent->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) + && _check_inherited_return_type(child, child->common.arg_info - 1, + parent, parent->common.arg_info - 1) != INHERITANCE_SUCCESS + )) { level = E_ERROR; verb = "must"; @@ -2196,10 +2167,19 @@ ZEND_API void zend_verify_variance(zend_class_entry *ce) ZEND_HASH_FOREACH_PTR(&ce->function_table, child) { zend_function *parent = child->common.prototype; + + /* Methods without prototypes do not need checked for variance. */ if (!parent) { continue; } + /* If a method's scope does not match this class, then it has been + * inherited without being overridden. We do not need to re-check + * these types. */ + if (child->common.scope != ce) { + continue; + } + /* We are only willing to ignore this for internal functions because * extensions don't always define arg_info. */ if (_missing_internal_arginfo(parent)) { @@ -2229,7 +2209,6 @@ ZEND_API void zend_verify_variance(zend_class_entry *ce) parent, &parent->common.arg_info[-1]); if (check < 0) { _inheritance_runtime_error_msg(child, parent); - // todo: what to do with errors, not warnings? continue; } } else { diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 1474e3db8028f..4f0aa1e254502 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -6955,12 +6955,9 @@ ZEND_VM_HANDLER(146, ZEND_VERIFY_VARIANCE, CONST, UNUSED) SAVE_OPLINE(); zce = zend_lookup_class(Z_STR_P(RT_CONSTANT(opline, opline->op1))); - if (zce) { - zend_verify_variance(zce); - } else { - ZEND_ASSERT(EG(exception)); - HANDLE_EXCEPTION(); - } + ZEND_ASSERT(zce); + zend_verify_variance(zce); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index c6b80e803b751..8e5509ef6feab 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -9309,12 +9309,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_VARIANCE_SPEC_CONST_UNU SAVE_OPLINE(); zce = zend_lookup_class(Z_STR_P(RT_CONSTANT(opline, opline->op1))); - if (zce) { - zend_verify_variance(zce); - } else { - ZEND_ASSERT(EG(exception)); - HANDLE_EXCEPTION(); - } + ZEND_ASSERT(zce); + zend_verify_variance(zce); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } From 0573f82a734ad289c33d1aadc7f9b673a4958066 Mon Sep 17 00:00:00 2001 From: Levi Morrison Date: Thu, 10 Jan 2019 13:33:25 -0700 Subject: [PATCH 04/19] Support more type decl locations for variance --- Zend/zend_compile.c | 100 ++++++++++++++++++++++++++-------------- Zend/zend_inheritance.c | 31 +++++++++++-- 2 files changed, 91 insertions(+), 40 deletions(-) diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 8df5fa44f3c04..a8d8c3fd4ba19 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -5221,12 +5221,72 @@ void zend_compile_declare(zend_ast *ast) /* {{{ */ } /* }}} */ +static zend_ast **_ast_find(zend_ast **begin, zend_ast **end, + zend_bool (*pred)(zend_ast *)) { + for (; begin < end; ++begin) + if (pred(*begin)) + return begin; + return begin; +} + +static zend_bool _is_type_decl(zend_ast *ast) { + return ast && ast->kind == ZEND_AST_CLASS; +} + +static zend_bool _is_not_decl_stmt(zend_ast *ast) { + if (ast) { + /* todo: what else should be considered a decl stmt? */ + switch (ast->kind) { + case ZEND_AST_CLASS: + case ZEND_AST_CONST_DECL: + case ZEND_AST_FUNC_DECL: + return 0; + + default: + return 1; + } + } + + /* todo: why are these sometimes null? */ + return 0; +} + void zend_compile_stmt_list(zend_ast *ast) /* {{{ */ { - zend_ast_list *list = zend_ast_get_list(ast); - uint32_t i; - for (i = 0; i < list->children; ++i) { - zend_compile_stmt(list->child[i]); + zend_ast_list *const list = zend_ast_get_list(ast); + zend_ast ** const begin = list->child; + zend_ast ** const end = begin + list->children; + zend_ast **first_decl = _ast_find(begin, end, &_is_type_decl); + zend_ast **p; + + /* Compile opcodes before first type decl */ + for (p = begin; p < first_decl; ++p) { + zend_compile_stmt(*p); + } + + /* Compile decl stmts */ + while (first_decl != end) { + zend_ast **last_decl = _ast_find(first_decl, end, &_is_not_decl_stmt); + HashTable unverified_types; + HashTable *prev_unverified_types; + _backup_unverified_variance_types(&unverified_types, &prev_unverified_types); + + for (p = first_decl; p < last_decl; ++p) { + zend_compile_stmt(*p); + } + + _compile_verify_variance(&unverified_types); + + zend_hash_destroy(&unverified_types); + CG(unverified_types) = prev_unverified_types; + + /* There can be non-consecutive type decls, so continue searching */ + first_decl = _ast_find(last_decl, end, &_is_type_decl); + + /* Compile any stmts between the two type decls (or the end) */ + for (p = last_decl; p < first_decl; ++p) { + zend_compile_stmt(*p); + } } } /* }}} */ @@ -6343,7 +6403,7 @@ zend_op *zend_compile_class_decl(zend_ast *ast, zend_bool toplevel) /* {{{ */ if (CG(unverified_types)) { zend_hash_add_empty_element(CG(unverified_types), lcname); } else { - // todo: figure out why it's null; need a caller (somewhere) to initialize, emit, and destroy the unverified types + ZEND_ASSERT(0 && "todo: find out why this is null"); } } @@ -8178,36 +8238,6 @@ void zend_const_expr_to_zval(zval *result, zend_ast *ast) /* {{{ */ } /* }}} */ -static zend_bool _is_type_decl(zend_ast *ast) { - return ast && ast->kind == ZEND_AST_CLASS; -} - -static zend_bool _is_not_decl_stmt(zend_ast *ast) { - if (ast) { - /* todo: what else should be considered a decl stmt? */ - switch (ast->kind) { - case ZEND_AST_CLASS: - case ZEND_AST_CONST_DECL: - case ZEND_AST_FUNC_DECL: - return 0; - - default: - return 1; - } - } - - /* todo: why are these sometimes null? */ - return 0; -} - -static zend_ast **_ast_find(zend_ast **begin, zend_ast **end, - zend_bool (*pred)(zend_ast *)) { - for (; begin < end; ++begin) - if (pred(*begin)) - return begin; - return begin; -} - /* Same as compile_stmt, but with early binding */ void zend_compile_top_stmt(zend_ast *ast) /* {{{ */ { diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index 60d1fa3320d5b..bd4c5534a8a07 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -367,6 +367,7 @@ static _inheritance_status zend_do_perform_implementation_check(const zend_function *fe, const zend_function *proto) /* {{{ */ { uint32_t i, num_args; + _inheritance_status status; /* If it's a user function then arg_info == NULL means we don't have any parameters but * we still need to do the arg number checks. We are only willing to ignore this for internal @@ -422,24 +423,45 @@ _inheritance_status zend_do_perform_implementation_check(const zend_function *fe } } + status = INHERITANCE_SUCCESS; + for (i = 0; i < num_args; i++) { zend_arg_info *fe_arg_info = &fe->common.arg_info[i]; zend_arg_info *proto_arg_info = (i < proto->common.num_args) ? &proto->common.arg_info[i] : &proto->common.arg_info[proto->common.num_args]; - if (!_check_inherited_parameter_type(fe, fe_arg_info, proto, proto_arg_info)) { + _inheritance_status local_status = + _check_inherited_parameter_type(fe, fe_arg_info, proto, proto_arg_info); + if (local_status == INHERITANCE_ERROR) { return INHERITANCE_ERROR; + } else if (local_status == INHERITANCE_UNRESOLVED) { + status = INHERITANCE_UNRESOLVED; } } /* Check return type compatibility, but only if the prototype already specifies * a return type. Adding a new return type is always valid. */ if (proto->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) { - return _check_inherited_return_type( - fe, fe->common.arg_info - 1, proto, proto->common.arg_info - 1); + _inheritance_status local_result = + _check_inherited_return_type(fe, fe->common.arg_info - 1, + proto, proto->common.arg_info - 1); + if (local_result == INHERITANCE_ERROR) { + return INHERITANCE_ERROR; + } else if (local_result == INHERITANCE_UNRESOLVED) { + status = INHERITANCE_UNRESOLVED; + } } - return INHERITANCE_SUCCESS; + + /* + if (status == INHERITANCE_UNRESOLVED && CG(unverified_types)) { + zend_string *key = zend_string_tolower(fe->common.scope->name); + zend_hash_add_empty_element(CG(unverified_types), key); + zend_string_release(key); + } + */ + + return status; } /* }}} */ @@ -2247,7 +2269,6 @@ ZEND_API void zend_verify_variance(zend_class_entry *ce) if (check < 0) { _inheritance_runtime_error_msg(child, parent); - // todo: what to do with errors, not warnings? continue; } } From 11dea4abf62ed61591041e686f19cd9a4eedf4a1 Mon Sep 17 00:00:00 2001 From: Levi Morrison Date: Fri, 11 Jan 2019 09:18:07 -0700 Subject: [PATCH 05/19] Consolidate, rename, and add new variance tests --- .../variance/across_namespaces_001.phpt | 28 +++++++++++++++++++ .../variance/across_namespaces_002.phpt | 26 +++++++++++++++++ .../variance/conditional_001.phpt | 23 +++++++++++++++ .../variance/conditional_002.phpt | 23 +++++++++++++++ ...contravariant_nullable_param_succeeds.phpt | 0 .../contravariant_nullable_return_fails.phpt | 0 .../covariant_nullable_param_fails.phpt | 0 .../covariant_nullable_return_succeeds.phpt} | 0 .../invariant_param_and_return_succeeds.phpt | 0 .../nonconsecutive_declarations_001.phpt} | 0 .../nonconsecutive_declarations_002.phpt} | 0 .../variance}/object_variance.phpt | 0 .../parameter_types.phpt} | 0 .../variance/undefined_type_01.phpt} | 0 .../variance/undefined_type_02.phpt} | 0 .../variance/undefined_type_03.phpt} | 0 .../variance/undefined_type_04.phpt} | 0 ext/opcache/tests/opt/prop_types.phpt | 5 ++-- 18 files changed, 103 insertions(+), 2 deletions(-) create mode 100644 Zend/tests/type_declarations/variance/across_namespaces_001.phpt create mode 100644 Zend/tests/type_declarations/variance/across_namespaces_002.phpt create mode 100644 Zend/tests/type_declarations/variance/conditional_001.phpt create mode 100644 Zend/tests/type_declarations/variance/conditional_002.phpt rename Zend/tests/{nullable_types => type_declarations/variance}/contravariant_nullable_param_succeeds.phpt (100%) rename Zend/tests/{nullable_types => type_declarations/variance}/contravariant_nullable_return_fails.phpt (100%) rename Zend/tests/{nullable_types => type_declarations/variance}/covariant_nullable_param_fails.phpt (100%) rename Zend/tests/{nullable_types/covariant_nullable_return_succeds.phpt => type_declarations/variance/covariant_nullable_return_succeeds.phpt} (100%) rename Zend/tests/{nullable_types => type_declarations/variance}/invariant_param_and_return_succeeds.phpt (100%) rename Zend/tests/type_declarations/{nonconsecutive_variant_declarations_001.phpt => variance/nonconsecutive_declarations_001.phpt} (100%) rename Zend/tests/type_declarations/{nonconsecutive_variant_declarations_002.phpt => variance/nonconsecutive_declarations_002.phpt} (100%) rename Zend/tests/{object_types => type_declarations/variance}/object_variance.phpt (100%) rename Zend/tests/type_declarations/{parameter_type_variance.phpt => variance/parameter_types.phpt} (100%) rename Zend/tests/{typehints/undefined_type_during_variance_check_01.phpt => type_declarations/variance/undefined_type_01.phpt} (100%) rename Zend/tests/{typehints/undefined_type_during_variance_check_02.phpt => type_declarations/variance/undefined_type_02.phpt} (100%) rename Zend/tests/{typehints/undefined_type_during_variance_check_03.phpt => type_declarations/variance/undefined_type_03.phpt} (100%) rename Zend/tests/{typehints/undefined_type_during_variance_check_04.phpt => type_declarations/variance/undefined_type_04.phpt} (100%) diff --git a/Zend/tests/type_declarations/variance/across_namespaces_001.phpt b/Zend/tests/type_declarations/variance/across_namespaces_001.phpt new file mode 100644 index 0000000000000..7e017a4faeebb --- /dev/null +++ b/Zend/tests/type_declarations/variance/across_namespaces_001.phpt @@ -0,0 +1,28 @@ +--TEST-- +Variance checks work across same-file namespaces (brace style) +--FILE-- +foo(new \stdClass())); +} +?> +--EXPECTF-- +Warning: Declaration of Bar\B::foo(stdClass $x): Bar\B should be compatible with Foo\A::foo(Foo\B $x): Foo\A in %s on line %d +Bar\B diff --git a/Zend/tests/type_declarations/variance/across_namespaces_002.phpt b/Zend/tests/type_declarations/variance/across_namespaces_002.phpt new file mode 100644 index 0000000000000..4a2d5e5af9645 --- /dev/null +++ b/Zend/tests/type_declarations/variance/across_namespaces_002.phpt @@ -0,0 +1,26 @@ +--TEST-- +Variance checks work across same-file namespaces +--FILE-- +foo(new \stdClass())); +?> +--EXPECTF-- +Warning: Declaration of Bar\B::foo(stdClass $x): Bar\B should be compatible with Foo\A::foo(Foo\B $x): Foo\A in %s on line %d +Bar\B diff --git a/Zend/tests/type_declarations/variance/conditional_001.phpt b/Zend/tests/type_declarations/variance/conditional_001.phpt new file mode 100644 index 0000000000000..262fc2182e69f --- /dev/null +++ b/Zend/tests/type_declarations/variance/conditional_001.phpt @@ -0,0 +1,23 @@ +--TEST-- +Delayed variance checks work with conditional statements +--FILE-- + +--EXPECTF-- +B diff --git a/Zend/tests/type_declarations/variance/conditional_002.phpt b/Zend/tests/type_declarations/variance/conditional_002.phpt new file mode 100644 index 0000000000000..7c707f0c811f2 --- /dev/null +++ b/Zend/tests/type_declarations/variance/conditional_002.phpt @@ -0,0 +1,23 @@ +--TEST-- +Delayed variance checks work with conditional statements +--FILE-- + +--EXPECTF-- +Fatal error: Declaration of B::m(X $z): B must be compatible with A::m(Y $z): A in %s on line %d diff --git a/Zend/tests/nullable_types/contravariant_nullable_param_succeeds.phpt b/Zend/tests/type_declarations/variance/contravariant_nullable_param_succeeds.phpt similarity index 100% rename from Zend/tests/nullable_types/contravariant_nullable_param_succeeds.phpt rename to Zend/tests/type_declarations/variance/contravariant_nullable_param_succeeds.phpt diff --git a/Zend/tests/nullable_types/contravariant_nullable_return_fails.phpt b/Zend/tests/type_declarations/variance/contravariant_nullable_return_fails.phpt similarity index 100% rename from Zend/tests/nullable_types/contravariant_nullable_return_fails.phpt rename to Zend/tests/type_declarations/variance/contravariant_nullable_return_fails.phpt diff --git a/Zend/tests/nullable_types/covariant_nullable_param_fails.phpt b/Zend/tests/type_declarations/variance/covariant_nullable_param_fails.phpt similarity index 100% rename from Zend/tests/nullable_types/covariant_nullable_param_fails.phpt rename to Zend/tests/type_declarations/variance/covariant_nullable_param_fails.phpt diff --git a/Zend/tests/nullable_types/covariant_nullable_return_succeds.phpt b/Zend/tests/type_declarations/variance/covariant_nullable_return_succeeds.phpt similarity index 100% rename from Zend/tests/nullable_types/covariant_nullable_return_succeds.phpt rename to Zend/tests/type_declarations/variance/covariant_nullable_return_succeeds.phpt diff --git a/Zend/tests/nullable_types/invariant_param_and_return_succeeds.phpt b/Zend/tests/type_declarations/variance/invariant_param_and_return_succeeds.phpt similarity index 100% rename from Zend/tests/nullable_types/invariant_param_and_return_succeeds.phpt rename to Zend/tests/type_declarations/variance/invariant_param_and_return_succeeds.phpt diff --git a/Zend/tests/type_declarations/nonconsecutive_variant_declarations_001.phpt b/Zend/tests/type_declarations/variance/nonconsecutive_declarations_001.phpt similarity index 100% rename from Zend/tests/type_declarations/nonconsecutive_variant_declarations_001.phpt rename to Zend/tests/type_declarations/variance/nonconsecutive_declarations_001.phpt diff --git a/Zend/tests/type_declarations/nonconsecutive_variant_declarations_002.phpt b/Zend/tests/type_declarations/variance/nonconsecutive_declarations_002.phpt similarity index 100% rename from Zend/tests/type_declarations/nonconsecutive_variant_declarations_002.phpt rename to Zend/tests/type_declarations/variance/nonconsecutive_declarations_002.phpt diff --git a/Zend/tests/object_types/object_variance.phpt b/Zend/tests/type_declarations/variance/object_variance.phpt similarity index 100% rename from Zend/tests/object_types/object_variance.phpt rename to Zend/tests/type_declarations/variance/object_variance.phpt diff --git a/Zend/tests/type_declarations/parameter_type_variance.phpt b/Zend/tests/type_declarations/variance/parameter_types.phpt similarity index 100% rename from Zend/tests/type_declarations/parameter_type_variance.phpt rename to Zend/tests/type_declarations/variance/parameter_types.phpt diff --git a/Zend/tests/typehints/undefined_type_during_variance_check_01.phpt b/Zend/tests/type_declarations/variance/undefined_type_01.phpt similarity index 100% rename from Zend/tests/typehints/undefined_type_during_variance_check_01.phpt rename to Zend/tests/type_declarations/variance/undefined_type_01.phpt diff --git a/Zend/tests/typehints/undefined_type_during_variance_check_02.phpt b/Zend/tests/type_declarations/variance/undefined_type_02.phpt similarity index 100% rename from Zend/tests/typehints/undefined_type_during_variance_check_02.phpt rename to Zend/tests/type_declarations/variance/undefined_type_02.phpt diff --git a/Zend/tests/typehints/undefined_type_during_variance_check_03.phpt b/Zend/tests/type_declarations/variance/undefined_type_03.phpt similarity index 100% rename from Zend/tests/typehints/undefined_type_during_variance_check_03.phpt rename to Zend/tests/type_declarations/variance/undefined_type_03.phpt diff --git a/Zend/tests/typehints/undefined_type_during_variance_check_04.phpt b/Zend/tests/type_declarations/variance/undefined_type_04.phpt similarity index 100% rename from Zend/tests/typehints/undefined_type_during_variance_check_04.phpt rename to Zend/tests/type_declarations/variance/undefined_type_04.phpt diff --git a/ext/opcache/tests/opt/prop_types.phpt b/ext/opcache/tests/opt/prop_types.phpt index 33cb5fa03394a..41b3ac365b0ec 100644 --- a/ext/opcache/tests/opt/prop_types.phpt +++ b/ext/opcache/tests/opt/prop_types.phpt @@ -39,12 +39,13 @@ function noScope(Test $test) { ?> --EXPECTF-- -$_main: ; (lines=1, args=0, vars=0, tmps=0, ssa_vars=0, no_loops) +$_main: ; (lines=2, args=0, vars=0, tmps=0, ssa_vars=0, no_loops) ; (before dfa pass) ; %s ; return [long] RANGE[1..1] -BB0: start exit lines=[0-0] +BB0: start exit lines=[0-1] ; level=0 + VERIFY_VARIANCE string("test2") RETURN int(1) noScope: ; (lines=10, args=1, vars=1, tmps=1, ssa_vars=5, no_loops) From 6d4f998d96896d319ece11ac6206428a2bd1f246 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 26 Mar 2019 14:36:22 +0100 Subject: [PATCH 06/19] Fix assertion failure due to unresolved parent --- .../variance/parent_in_trait.phpt | 19 ++++++++++ Zend/zend_inheritance.c | 36 +++++++++---------- 2 files changed, 37 insertions(+), 18 deletions(-) create mode 100644 Zend/tests/type_declarations/variance/parent_in_trait.phpt diff --git a/Zend/tests/type_declarations/variance/parent_in_trait.phpt b/Zend/tests/type_declarations/variance/parent_in_trait.phpt new file mode 100644 index 0000000000000..d8ab1735a5ded --- /dev/null +++ b/Zend/tests/type_declarations/variance/parent_in_trait.phpt @@ -0,0 +1,19 @@ +--TEST-- +Trait using parent used inside class without parent +--FILE-- + +--EXPECTF-- +Warning: Declaration of B::foo(A $x) should be compatible with A::foo(parent $x) in %s on line %d diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index bd4c5534a8a07..2538a84496ee1 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -184,34 +184,27 @@ static zend_always_inline zend_bool zend_iterable_compatibility_check(zend_arg_i } /* }}} */ -/* todo: this is probably useful elsewhere too */ -/* caller is responsible for adding any necessary refcount */ static zend_string *_get_parent_class_name(zend_class_entry *ce) -{ /* {{{ */ - zend_string *pname; - +{ if (ce->ce_flags & ZEND_ACC_LINKED) { - ZEND_ASSERT(ce->parent); - pname = ce->parent->name; + return ce->parent ? ce->parent->name : NULL; } else { - pname = ce->parent_name; + return ce->parent_name; } +} - /* If there is a parent, it must have a name */ - ZEND_ASSERT(pname); - return pname; -}/* }}} */ - -static -zend_string *_resolve_parent_and_self(const zend_function *fe, zend_string *name) +static zend_string *_resolve_parent_and_self(const zend_function *fe, zend_string *name) { /* {{{ */ zend_class_entry *ce = fe->common.scope; /* if there isn't a class then we shouldn't be resolving parent and self */ - ZEND_ASSERT(fe->common.scope); + ZEND_ASSERT(ce); switch (zend_get_class_fetch_type(name)) { case ZEND_FETCH_CLASS_PARENT: name = _get_parent_class_name(ce); + if (!name) { + return NULL; + } break; case ZEND_FETCH_CLASS_SELF: @@ -262,12 +255,19 @@ _inheritance_status _check_covariance( } if (ZEND_TYPE_IS_CLASS(fe_type)) { - zend_string *fe_class_name = - _resolve_parent_and_self(fe, ZEND_TYPE_NAME(fe_type)); _inheritance_status code; + zend_string *fe_class_name = _resolve_parent_and_self(fe, ZEND_TYPE_NAME(fe_type)); + if (!fe_class_name) { + return INHERITANCE_UNRESOLVED; + } + if (ZEND_TYPE_IS_CLASS(proto_type)) { zend_string *proto_class_name = _resolve_parent_and_self(proto, ZEND_TYPE_NAME(proto_type)); + if (!proto_class_name) { + zend_string_free(fe_class_name); + return INHERITANCE_UNRESOLVED; + } if (zend_string_equals_ci(fe_class_name, proto_class_name)) { code = INHERITANCE_SUCCESS; From 886cb5c14ebc187031240f3577637aca4370d3aa Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 26 Mar 2019 15:10:21 +0100 Subject: [PATCH 07/19] Add one more parent test Exposes an unrelated issue: Line numbers are incorrect. --- .../variance/parent_in_class.phpt | 45 +++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 Zend/tests/type_declarations/variance/parent_in_class.phpt diff --git a/Zend/tests/type_declarations/variance/parent_in_class.phpt b/Zend/tests/type_declarations/variance/parent_in_class.phpt new file mode 100644 index 0000000000000..861090804d201 --- /dev/null +++ b/Zend/tests/type_declarations/variance/parent_in_class.phpt @@ -0,0 +1,45 @@ +--TEST-- +Use of parent inside a class that has / has no parent +--FILE-- + +--EXPECTF-- +Warning: Declaration of B4::method(A4 $x) should be compatible with A4::method(P4 $x) in %s on line 35 + +Warning: Declaration of B::method(A $x) should be compatible with A::method(parent $x) in %s on line 36 From 6d14d6b48b2fde9d62f62c03a0e7333deff56c61 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 26 Mar 2019 16:02:53 +0100 Subject: [PATCH 08/19] Correct lineno for runtime variance error --- Zend/tests/type_declarations/variance/parent_in_class.phpt | 2 +- Zend/zend_inheritance.c | 4 +++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/Zend/tests/type_declarations/variance/parent_in_class.phpt b/Zend/tests/type_declarations/variance/parent_in_class.phpt index 861090804d201..c527d7dcf98da 100644 --- a/Zend/tests/type_declarations/variance/parent_in_class.phpt +++ b/Zend/tests/type_declarations/variance/parent_in_class.phpt @@ -42,4 +42,4 @@ class B4 extends A4 { --EXPECTF-- Warning: Declaration of B4::method(A4 $x) should be compatible with A4::method(P4 $x) in %s on line 35 -Warning: Declaration of B::method(A $x) should be compatible with A::method(parent $x) in %s on line 36 +Warning: Declaration of B::method(A $x) should be compatible with A::method(parent $x) in %s on line 8 diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index 2538a84496ee1..690a888b0b953 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -2171,9 +2171,11 @@ static void _inheritance_runtime_error_msg(zend_function *child, zend_function * verb = "must"; } { + ZEND_ASSERT(child->type == ZEND_USER_FUNCTION); zend_string *method_prototype = zend_get_function_declaration(parent); zend_string *child_prototype = zend_get_function_declaration(child); - zend_error(level, "Declaration of %s %s be compatible with %s", + zend_error_at(level, NULL, child->op_array.line_start, + "Declaration of %s %s be compatible with %s", ZSTR_VAL(child_prototype), verb, ZSTR_VAL(method_prototype)); zend_string_efree(child_prototype); zend_string_efree(method_prototype); From cbcbc2495bb805e7953dd0d63ad589c653b70e98 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 26 Mar 2019 16:17:06 +0100 Subject: [PATCH 09/19] Replace error with assert --- Zend/zend_inheritance.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index 690a888b0b953..6dab14bb185ab 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -216,10 +216,9 @@ static zend_string *_resolve_parent_and_self(const zend_function *fe, zend_strin break; case ZEND_FETCH_CLASS_STATIC: - /* Note: this currently a syntax error */ - zend_error_noreturn(E_COMPILE_ERROR, - "Cannot use static as a type constraint in %s::%s()", - ZEND_FN_SCOPE_NAME(fe), ZSTR_VAL(fe->common.function_name)); + /* This currently a syntax error */ + ZEND_ASSERT(0); + break; EMPTY_SWITCH_DEFAULT_CASE(); } From c0c30c0d22eed1fdcde688691d55401ebfb5d2f1 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 26 Mar 2019 16:30:22 +0100 Subject: [PATCH 10/19] Check class visibility wrt to opcache --- Zend/zend_inheritance.c | 28 +++++++++++++++++++++++++--- 1 file changed, 25 insertions(+), 3 deletions(-) diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index 6dab14bb185ab..c21fffec138e1 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -226,6 +226,28 @@ static zend_string *_resolve_parent_and_self(const zend_function *fe, zend_strin return zend_string_copy(name); } /* }}} */ +static zend_bool class_visible(zend_class_entry *ce) { + if (CG(in_compilation)) { + return 1; + } + if (ce->type == ZEND_INTERNAL_CLASS) { + return !(CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_CLASSES); + } else { + ZEND_ASSERT(ce->type == ZEND_USER_CLASS); + return !(CG(compiler_options) & ZEND_COMPILE_IGNORE_OTHER_FILES) + || ce->info.user.filename == CG(compiled_filename); + } +} + +zend_class_entry *lookup_class(zend_string *name) { + zend_class_entry *ce = zend_lookup_class(name); + if (!ce) { + return NULL; + } + + return class_visible(ce) ? ce : NULL; +} + typedef enum { INHERITANCE_UNRESOLVED = -1, INHERITANCE_ERROR = 0, @@ -272,8 +294,8 @@ _inheritance_status _check_covariance( code = INHERITANCE_SUCCESS; } else { if (fe->common.type == ZEND_USER_FUNCTION) { - zend_class_entry *fe_ce = zend_lookup_class(fe_class_name); - zend_class_entry *proto_ce = zend_lookup_class(proto_class_name); + zend_class_entry *fe_ce = lookup_class(fe_class_name); + zend_class_entry *proto_ce = lookup_class(proto_class_name); if (fe_ce && proto_ce) { code = instanceof_function(fe_ce, proto_ce) @@ -289,7 +311,7 @@ _inheritance_status _check_covariance( } zend_string_release(proto_class_name); } else if (proto_type_code == IS_ITERABLE) { - zend_class_entry *fe_ce = zend_lookup_class(fe_class_name); + zend_class_entry *fe_ce = lookup_class(fe_class_name); if (fe_ce) { code = instanceof_function(fe_ce, zend_ce_traversable) ? INHERITANCE_SUCCESS From e5208bff6f91362d1f4c025f2067661cf552ed78 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 26 Mar 2019 16:46:57 +0100 Subject: [PATCH 11/19] Make sure to load the class for object variance --- .../variance/enum_forward_compat.phpt | 26 +++++++++++++++++++ Zend/zend_inheritance.c | 3 ++- 2 files changed, 28 insertions(+), 1 deletion(-) create mode 100644 Zend/tests/type_declarations/variance/enum_forward_compat.phpt diff --git a/Zend/tests/type_declarations/variance/enum_forward_compat.phpt b/Zend/tests/type_declarations/variance/enum_forward_compat.phpt new file mode 100644 index 0000000000000..a183d0786a641 --- /dev/null +++ b/Zend/tests/type_declarations/variance/enum_forward_compat.phpt @@ -0,0 +1,26 @@ +--TEST-- +Forward compatibility with types that look like classes but aren't +--FILE-- + +--EXPECT-- +string(1) "Y" +string(1) "X" diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index c21fffec138e1..4063a24d3e490 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -320,7 +320,8 @@ _inheritance_status _check_covariance( code = INHERITANCE_UNRESOLVED; } } else if (proto_type_code == IS_OBJECT) { - code = INHERITANCE_SUCCESS; + zend_class_entry *fe_ce = lookup_class(fe_class_name); + code = fe_ce ? INHERITANCE_SUCCESS : INHERITANCE_UNRESOLVED; } else { code = INHERITANCE_ERROR; } From f1344fbdf864d08e8fac0cc9fdb7afa5e0129fdc Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 26 Mar 2019 16:48:11 +0100 Subject: [PATCH 12/19] Coding style --- Zend/zend_inheritance.c | 27 ++++++++++++--------------- 1 file changed, 12 insertions(+), 15 deletions(-) diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index 4063a24d3e490..27eed9703de4a 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -252,14 +252,13 @@ typedef enum { INHERITANCE_UNRESOLVED = -1, INHERITANCE_ERROR = 0, INHERITANCE_SUCCESS = 1, -} _inheritance_status; +} inheritance_status; /* Parameters are contravariant; return types are covariant. We can rely on * the fact that they are inverses to improve correctness and simplify code. * We can implement covariance, and then implement contravariance simply by * reversing the argument order. */ -static -_inheritance_status _check_covariance( +static inheritance_status _check_covariance( const zend_function *fe, zend_arg_info *fe_arg_info, const zend_function *proto, zend_arg_info *proto_arg_info) { /* {{{ */ @@ -276,7 +275,7 @@ _inheritance_status _check_covariance( } if (ZEND_TYPE_IS_CLASS(fe_type)) { - _inheritance_status code; + inheritance_status code; zend_string *fe_class_name = _resolve_parent_and_self(fe, ZEND_TYPE_NAME(fe_type)); if (!fe_class_name) { return INHERITANCE_UNRESOLVED; @@ -340,8 +339,7 @@ _inheritance_status _check_covariance( } /* }}} */ -static -_inheritance_status _check_inherited_return_type( +static inheritance_status _check_inherited_return_type( const zend_function *fe, zend_arg_info *fe_arg_info, const zend_function *proto, zend_arg_info *proto_arg_info) /* {{{ */ { @@ -359,8 +357,7 @@ static zend_bool _missing_internal_arginfo(zend_function const *fn) return !fn->common.arg_info && fn->common.type == ZEND_INTERNAL_FUNCTION; } -static -_inheritance_status _check_inherited_parameter_type( +static inheritance_status _check_inherited_parameter_type( const zend_function *fe, zend_arg_info *fe_arg_info, const zend_function *proto, zend_arg_info *proto_arg_info) /* {{{ */ { @@ -385,11 +382,11 @@ _inheritance_status _check_inherited_parameter_type( } /* }}} */ -static -_inheritance_status zend_do_perform_implementation_check(const zend_function *fe, const zend_function *proto) /* {{{ */ +static inheritance_status zend_do_perform_implementation_check( + const zend_function *fe, const zend_function *proto) /* {{{ */ { uint32_t i, num_args; - _inheritance_status status; + inheritance_status status; /* If it's a user function then arg_info == NULL means we don't have any parameters but * we still need to do the arg number checks. We are only willing to ignore this for internal @@ -453,7 +450,7 @@ _inheritance_status zend_do_perform_implementation_check(const zend_function *fe ? &proto->common.arg_info[i] : &proto->common.arg_info[proto->common.num_args]; - _inheritance_status local_status = + inheritance_status local_status = _check_inherited_parameter_type(fe, fe_arg_info, proto, proto_arg_info); if (local_status == INHERITANCE_ERROR) { return INHERITANCE_ERROR; @@ -465,9 +462,9 @@ _inheritance_status zend_do_perform_implementation_check(const zend_function *fe /* Check return type compatibility, but only if the prototype already specifies * a return type. Adding a new return type is always valid. */ if (proto->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) { - _inheritance_status local_result = - _check_inherited_return_type(fe, fe->common.arg_info - 1, - proto, proto->common.arg_info - 1); + inheritance_status local_result = + _check_inherited_return_type( + fe, fe->common.arg_info - 1, proto, proto->common.arg_info - 1); if (local_result == INHERITANCE_ERROR) { return INHERITANCE_ERROR; } else if (local_result == INHERITANCE_UNRESOLVED) { From 7c5ffa638f717c14c7d17d824ed774c75d204922 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 26 Mar 2019 16:58:33 +0100 Subject: [PATCH 13/19] Don't add a ref when resolving parent/self Don't see any reason why we should do that? --- Zend/zend_inheritance.c | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index 27eed9703de4a..c1cf4d29646dc 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -196,7 +196,7 @@ static zend_string *_get_parent_class_name(zend_class_entry *ce) static zend_string *_resolve_parent_and_self(const zend_function *fe, zend_string *name) { /* {{{ */ zend_class_entry *ce = fe->common.scope; - /* if there isn't a class then we shouldn't be resolving parent and self */ + /* If there isn't a class then we shouldn't be resolving parent and self. */ ZEND_ASSERT(ce); switch (zend_get_class_fetch_type(name)) { @@ -212,18 +212,18 @@ static zend_string *_resolve_parent_and_self(const zend_function *fe, zend_strin break; case ZEND_FETCH_CLASS_DEFAULT: - /* already resolved */ + /* Already resolved. */ break; case ZEND_FETCH_CLASS_STATIC: - /* This currently a syntax error */ + /* This is currently a syntax error. */ ZEND_ASSERT(0); break; EMPTY_SWITCH_DEFAULT_CASE(); } - return zend_string_copy(name); + return name; } /* }}} */ static zend_bool class_visible(zend_class_entry *ce) { @@ -285,7 +285,6 @@ static inheritance_status _check_covariance( zend_string *proto_class_name = _resolve_parent_and_self(proto, ZEND_TYPE_NAME(proto_type)); if (!proto_class_name) { - zend_string_free(fe_class_name); return INHERITANCE_UNRESOLVED; } @@ -308,7 +307,6 @@ static inheritance_status _check_covariance( code = INHERITANCE_ERROR; } } - zend_string_release(proto_class_name); } else if (proto_type_code == IS_ITERABLE) { zend_class_entry *fe_ce = lookup_class(fe_class_name); if (fe_ce) { @@ -325,7 +323,6 @@ static inheritance_status _check_covariance( code = INHERITANCE_ERROR; } - zend_string_release(fe_class_name); return code; } else if (ZEND_TYPE_IS_CLASS(proto_type)) { return INHERITANCE_ERROR; From 9fb69ea441563b130f680912e9d738d2ce065ddf Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 26 Mar 2019 17:16:26 +0100 Subject: [PATCH 14/19] Refactor variance check code Classify by proto type. Add a helper for resolve&lookup as there's now more places where we have to lookup the class... but I think it's more obvious this way, rather than splitting the class and non-class cases. --- Zend/zend_inheritance.c | 113 ++++++++++++++++++++++------------------ 1 file changed, 61 insertions(+), 52 deletions(-) diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index c1cf4d29646dc..8b813f620e5a8 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -184,7 +184,7 @@ static zend_always_inline zend_bool zend_iterable_compatibility_check(zend_arg_i } /* }}} */ -static zend_string *_get_parent_class_name(zend_class_entry *ce) +static zend_string *get_parent_class_name(zend_class_entry *ce) { if (ce->ce_flags & ZEND_ACC_LINKED) { return ce->parent ? ce->parent->name : NULL; @@ -193,7 +193,7 @@ static zend_string *_get_parent_class_name(zend_class_entry *ce) } } -static zend_string *_resolve_parent_and_self(const zend_function *fe, zend_string *name) +static zend_string *resolve_parent_and_self(const zend_function *fe, zend_string *name) { /* {{{ */ zend_class_entry *ce = fe->common.scope; /* If there isn't a class then we shouldn't be resolving parent and self. */ @@ -201,7 +201,7 @@ static zend_string *_resolve_parent_and_self(const zend_function *fe, zend_strin switch (zend_get_class_fetch_type(name)) { case ZEND_FETCH_CLASS_PARENT: - name = _get_parent_class_name(ce); + name = get_parent_class_name(ce); if (!name) { return NULL; } @@ -239,7 +239,7 @@ static zend_bool class_visible(zend_class_entry *ce) { } } -zend_class_entry *lookup_class(zend_string *name) { +static zend_class_entry *lookup_class(zend_string *name) { zend_class_entry *ce = zend_lookup_class(name); if (!ce) { return NULL; @@ -248,6 +248,15 @@ zend_class_entry *lookup_class(zend_string *name) { return class_visible(ce) ? ce : NULL; } +static zend_class_entry *resolve_and_lookup_class(const zend_function *fe, zend_string *name) { + zend_string *resolved_name = resolve_parent_and_self(fe, name); + if (!resolved_name) { + return NULL; + } + + return lookup_class(resolved_name); +} + typedef enum { INHERITANCE_UNRESOLVED = -1, INHERITANCE_ERROR = 0, @@ -274,65 +283,65 @@ static inheritance_status _check_covariance( return INHERITANCE_ERROR; } - if (ZEND_TYPE_IS_CLASS(fe_type)) { - inheritance_status code; - zend_string *fe_class_name = _resolve_parent_and_self(fe, ZEND_TYPE_NAME(fe_type)); - if (!fe_class_name) { + if (ZEND_TYPE_IS_CLASS(proto_type)) { + zend_string *proto_class_name; + zend_string *fe_class_name; + if (!ZEND_TYPE_IS_CLASS(fe_type)) { + return INHERITANCE_ERROR; + } + + proto_class_name = resolve_parent_and_self(proto, ZEND_TYPE_NAME(proto_type)); + fe_class_name = resolve_parent_and_self(fe, ZEND_TYPE_NAME(fe_type)); + if (!proto_class_name || !fe_class_name) { return INHERITANCE_UNRESOLVED; } - if (ZEND_TYPE_IS_CLASS(proto_type)) { - zend_string *proto_class_name = - _resolve_parent_and_self(proto, ZEND_TYPE_NAME(proto_type)); - if (!proto_class_name) { + if (zend_string_equals_ci(fe_class_name, proto_class_name)) { + return INHERITANCE_SUCCESS; + } + + if (fe->common.type == ZEND_USER_FUNCTION) { + zend_class_entry *fe_ce = lookup_class(fe_class_name); + zend_class_entry *proto_ce = lookup_class(proto_class_name); + if (!fe_ce || !proto_ce) { return INHERITANCE_UNRESOLVED; } - if (zend_string_equals_ci(fe_class_name, proto_class_name)) { - code = INHERITANCE_SUCCESS; - } else { - if (fe->common.type == ZEND_USER_FUNCTION) { - zend_class_entry *fe_ce = lookup_class(fe_class_name); - zend_class_entry *proto_ce = lookup_class(proto_class_name); - - if (fe_ce && proto_ce) { - code = instanceof_function(fe_ce, proto_ce) - ? INHERITANCE_SUCCESS - : INHERITANCE_ERROR; - } else { - code = INHERITANCE_UNRESOLVED; - } - } else { - /* todo: what should this actually do? */ - code = INHERITANCE_ERROR; + return instanceof_function(fe_ce, proto_ce) + ? INHERITANCE_SUCCESS + : INHERITANCE_ERROR; + } else { + /* TODO: what should this actually do? */ + return INHERITANCE_ERROR; + } + } + + switch (proto_type_code) { + case IS_ITERABLE: + if (ZEND_TYPE_IS_CLASS(fe_type)) { + zend_class_entry *fe_ce = resolve_and_lookup_class(fe, ZEND_TYPE_NAME(fe_type)); + if (!fe_ce) { + return INHERITANCE_UNRESOLVED; } + return instanceof_function(fe_ce, zend_ce_traversable) + ? INHERITANCE_SUCCESS : INHERITANCE_ERROR; } - } else if (proto_type_code == IS_ITERABLE) { - zend_class_entry *fe_ce = lookup_class(fe_class_name); - if (fe_ce) { - code = instanceof_function(fe_ce, zend_ce_traversable) - ? INHERITANCE_SUCCESS - : INHERITANCE_ERROR; - } else { - code = INHERITANCE_UNRESOLVED; + return fe_type_code == IS_ITERABLE || fe_type_code == IS_ARRAY + ? INHERITANCE_SUCCESS : INHERITANCE_ERROR; + + case IS_OBJECT: + if (ZEND_TYPE_IS_CLASS(fe_type)) { + zend_class_entry *fe_ce = resolve_and_lookup_class(fe, ZEND_TYPE_NAME(fe_type)); + if (!fe_ce) { + return INHERITANCE_UNRESOLVED; + } + return INHERITANCE_SUCCESS; } - } else if (proto_type_code == IS_OBJECT) { - zend_class_entry *fe_ce = lookup_class(fe_class_name); - code = fe_ce ? INHERITANCE_SUCCESS : INHERITANCE_UNRESOLVED; - } else { - code = INHERITANCE_ERROR; - } + return fe_type_code == IS_OBJECT ? INHERITANCE_SUCCESS : INHERITANCE_ERROR; - return code; - } else if (ZEND_TYPE_IS_CLASS(proto_type)) { - return INHERITANCE_ERROR; - } else if (proto_type_code == IS_ITERABLE) { - return fe_type_code == IS_ARRAY ? INHERITANCE_SUCCESS : INHERITANCE_ERROR; - } else if (fe_type_code == proto_type_code) { - return INHERITANCE_SUCCESS; + default: + return fe_type_code == proto_type_code ? INHERITANCE_SUCCESS : INHERITANCE_ERROR; } - - return INHERITANCE_ERROR; } /* }}} */ From b4da03424e62daa70e7c8936238f7693a5ed76a0 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Tue, 26 Mar 2019 17:36:25 +0100 Subject: [PATCH 15/19] Support class variance for internal classes --- Zend/zend_inheritance.c | 39 ++++++++++++++++++++------------------- ext/zend_test/test.c | 30 ++++++++++++++++++++++++++++-- 2 files changed, 48 insertions(+), 21 deletions(-) diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index 8b813f620e5a8..0293cc987f2b5 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -240,12 +240,18 @@ static zend_bool class_visible(zend_class_entry *ce) { } static zend_class_entry *lookup_class(zend_string *name) { - zend_class_entry *ce = zend_lookup_class(name); - if (!ce) { - return NULL; + zend_class_entry *ce; + if (EG(active)) { + ce = zend_lookup_class(name); + } else { + /* When a class lookup is necessary during internal class registration in early + * startup, look it up in CG(class_table), as the executor is not active yet. */ + zend_string *lcname = zend_string_tolower(name); + ce = zend_hash_find_ptr(CG(class_table), lcname); + zend_string_release(lcname); } - return class_visible(ce) ? ce : NULL; + return ce && class_visible(ce) ? ce : NULL; } static zend_class_entry *resolve_and_lookup_class(const zend_function *fe, zend_string *name) { @@ -284,8 +290,8 @@ static inheritance_status _check_covariance( } if (ZEND_TYPE_IS_CLASS(proto_type)) { - zend_string *proto_class_name; - zend_string *fe_class_name; + zend_string *proto_class_name, *fe_class_name; + zend_class_entry *proto_ce, *fe_ce; if (!ZEND_TYPE_IS_CLASS(fe_type)) { return INHERITANCE_ERROR; } @@ -300,20 +306,15 @@ static inheritance_status _check_covariance( return INHERITANCE_SUCCESS; } - if (fe->common.type == ZEND_USER_FUNCTION) { - zend_class_entry *fe_ce = lookup_class(fe_class_name); - zend_class_entry *proto_ce = lookup_class(proto_class_name); - if (!fe_ce || !proto_ce) { - return INHERITANCE_UNRESOLVED; - } - - return instanceof_function(fe_ce, proto_ce) - ? INHERITANCE_SUCCESS - : INHERITANCE_ERROR; - } else { - /* TODO: what should this actually do? */ - return INHERITANCE_ERROR; + fe_ce = lookup_class(fe_class_name); + proto_ce = lookup_class(proto_class_name); + if (!fe_ce || !proto_ce) { + return INHERITANCE_UNRESOLVED; } + + return instanceof_function(fe_ce, proto_ce) + ? INHERITANCE_SUCCESS + : INHERITANCE_ERROR; } switch (proto_type_code) { diff --git a/ext/zend_test/test.c b/ext/zend_test/test.c index 53af862d24492..524f3cc7cc85c 100644 --- a/ext/zend_test/test.c +++ b/ext/zend_test/test.c @@ -179,11 +179,37 @@ static int zend_test_class_call_method(zend_string *method, zend_object *object, } /* }}} */ +static ZEND_METHOD(_ZendTestClass, varianceTest) /* {{{ */ { + RETURN_TRUE; +} +/* }}} */ + +static ZEND_METHOD(_ZendTestChildClass, varianceTest) /* {{{ */ { + RETURN_TRUE; +} +/* }}} */ + static ZEND_METHOD(_ZendTestTrait, testMethod) /* {{{ */ { RETURN_TRUE; } /* }}} */ +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_parent, 0, 0, _ZendTestClass, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_child, 0, 0, _ZendTestChildClass, 0) +ZEND_END_ARG_INFO() + +static const zend_function_entry zend_test_class_methods[] = { + ZEND_ME(_ZendTestClass, varianceTest, arginfo_parent, ZEND_ACC_PUBLIC) + ZEND_FE_END +}; + +static const zend_function_entry zend_test_child_class_methods[] = { + ZEND_ME(_ZendTestChildClass, varianceTest, arginfo_child, ZEND_ACC_PUBLIC) + ZEND_FE_END +}; + static const zend_function_entry zend_test_trait_methods[] = { ZEND_ME(_ZendTestTrait, testMethod, NULL, ZEND_ACC_PUBLIC) ZEND_FE_END @@ -196,7 +222,7 @@ PHP_MINIT_FUNCTION(zend_test) INIT_CLASS_ENTRY(class_entry, "_ZendTestInterface", NULL); zend_test_interface = zend_register_internal_interface(&class_entry); zend_declare_class_constant_long(zend_test_interface, ZEND_STRL("DUMMY"), 0); - INIT_CLASS_ENTRY(class_entry, "_ZendTestClass", NULL); + INIT_CLASS_ENTRY(class_entry, "_ZendTestClass", zend_test_class_methods); zend_test_class = zend_register_internal_class_ex(&class_entry, NULL); zend_class_implements(zend_test_class, 1, zend_test_interface); zend_test_class->create_object = zend_test_class_new; @@ -234,7 +260,7 @@ PHP_MINIT_FUNCTION(zend_test) zend_string_release(name); } - INIT_CLASS_ENTRY(class_entry, "_ZendTestChildClass", NULL); + INIT_CLASS_ENTRY(class_entry, "_ZendTestChildClass", zend_test_child_class_methods); zend_test_child_class = zend_register_internal_class_ex(&class_entry, zend_test_class); memcpy(&zend_test_class_handlers, &std_object_handlers, sizeof(zend_object_handlers)); From 3db6f930f1dfddc5095c399081e819c1c8f1344a Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Wed, 27 Mar 2019 10:31:38 +0100 Subject: [PATCH 16/19] Coding style --- Zend/zend_inheritance.c | 44 ++++++++++++++++++++--------------------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index 0293cc987f2b5..40b68c171232c 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -273,7 +273,7 @@ typedef enum { * the fact that they are inverses to improve correctness and simplify code. * We can implement covariance, and then implement contravariance simply by * reversing the argument order. */ -static inheritance_status _check_covariance( +static inheritance_status check_covariance( const zend_function *fe, zend_arg_info *fe_arg_info, const zend_function *proto, zend_arg_info *proto_arg_info) { /* {{{ */ @@ -346,7 +346,7 @@ static inheritance_status _check_covariance( } /* }}} */ -static inheritance_status _check_inherited_return_type( +static inheritance_status check_inherited_return_type( const zend_function *fe, zend_arg_info *fe_arg_info, const zend_function *proto, zend_arg_info *proto_arg_info) /* {{{ */ { @@ -355,21 +355,20 @@ static inheritance_status _check_inherited_return_type( return INHERITANCE_ERROR; } - return _check_covariance(fe, fe_arg_info, proto, proto_arg_info); + return check_covariance(fe, fe_arg_info, proto, proto_arg_info); } - -static zend_bool _missing_internal_arginfo(zend_function const *fn) +static zend_bool missing_internal_arginfo(zend_function const *fn) { return !fn->common.arg_info && fn->common.type == ZEND_INTERNAL_FUNCTION; } -static inheritance_status _check_inherited_parameter_type( +static inheritance_status check_inherited_parameter_type( const zend_function *fe, zend_arg_info *fe_arg_info, const zend_function *proto, zend_arg_info *proto_arg_info) /* {{{ */ { - /* by-ref constraints on arguments are invariant */ + /* By-ref constraints on arguments are invariant */ if (fe_arg_info->pass_by_reference != proto_arg_info->pass_by_reference) { return INHERITANCE_ERROR; } @@ -385,7 +384,7 @@ static inheritance_status _check_inherited_parameter_type( } /* CONTRAVARIANT is inverse of COVARIANT, so call with reversed args. */ - return _check_covariance(proto, proto_arg_info, fe, fe_arg_info); + return check_covariance(proto, proto_arg_info, fe, fe_arg_info); } /* }}} */ @@ -399,7 +398,7 @@ static inheritance_status zend_do_perform_implementation_check( * we still need to do the arg number checks. We are only willing to ignore this for internal * functions because extensions don't always define arg_info. */ - if (_missing_internal_arginfo(proto)) { + if (missing_internal_arginfo(proto)) { return INHERITANCE_SUCCESS; } @@ -458,7 +457,7 @@ static inheritance_status zend_do_perform_implementation_check( : &proto->common.arg_info[proto->common.num_args]; inheritance_status local_status = - _check_inherited_parameter_type(fe, fe_arg_info, proto, proto_arg_info); + check_inherited_parameter_type(fe, fe_arg_info, proto, proto_arg_info); if (local_status == INHERITANCE_ERROR) { return INHERITANCE_ERROR; } else if (local_status == INHERITANCE_UNRESOLVED) { @@ -470,7 +469,7 @@ static inheritance_status zend_do_perform_implementation_check( * a return type. Adding a new return type is always valid. */ if (proto->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) { inheritance_status local_result = - _check_inherited_return_type( + check_inherited_return_type( fe, fe->common.arg_info - 1, proto, proto->common.arg_info - 1); if (local_result == INHERITANCE_ERROR) { return INHERITANCE_ERROR; @@ -750,7 +749,7 @@ static void do_inheritance_check_on_method(zend_function *child, zend_function * error_level = E_COMPILE_ERROR; error_verb = "must"; } else if ((parent->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) && - !_check_inherited_return_type(child, child->common.arg_info - 1, parent, parent->common.arg_info - 1)) { + !check_inherited_return_type(child, child->common.arg_info - 1, parent, parent->common.arg_info - 1)) { error_level = E_COMPILE_ERROR; error_verb = "must"; } else { @@ -2181,7 +2180,7 @@ ZEND_API void zend_do_link_class(zend_class_entry *ce, zend_class_entry *parent) } /* }}} */ -static void _inheritance_runtime_error_msg(zend_function *child, zend_function *parent) +static void inheritance_runtime_error_msg(zend_function *child, zend_function *parent) { int level = E_WARNING; const char *verb = "should"; @@ -2189,7 +2188,7 @@ static void _inheritance_runtime_error_msg(zend_function *child, zend_function * if ((parent->common.fn_flags & ZEND_ACC_ABSTRACT) || ( (parent->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) - && _check_inherited_return_type(child, child->common.arg_info - 1, + && check_inherited_return_type(child, child->common.arg_info - 1, parent, parent->common.arg_info - 1) != INHERITANCE_SUCCESS )) { @@ -2232,7 +2231,7 @@ ZEND_API void zend_verify_variance(zend_class_entry *ce) /* We are only willing to ignore this for internal functions because * extensions don't always define arg_info. */ - if (_missing_internal_arginfo(parent)) { + if (missing_internal_arginfo(parent)) { continue; } @@ -2254,11 +2253,13 @@ ZEND_API void zend_verify_variance(zend_class_entry *ce) * specifies a return type. Adding a new return type is always valid. */ if (parent->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) { if (child->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) { - int check = _check_inherited_return_type( + inheritance_status status = check_inherited_return_type( child, &child->common.arg_info[-1], parent, &parent->common.arg_info[-1]); - if (check < 0) { - _inheritance_runtime_error_msg(child, parent); + /* TODO I don't think this is right -- what if the class now exists + * but has wrong variance? */ + if (status == INHERITANCE_UNRESOLVED) { + inheritance_runtime_error_msg(child, parent); continue; } } else { @@ -2291,12 +2292,11 @@ ZEND_API void zend_verify_variance(zend_class_entry *ce) ? &parent->common.arg_info[i] : &parent->common.arg_info[parent->common.num_args]; - int check = _check_inherited_parameter_type( + inheritance_status status = check_inherited_parameter_type( child, child_arg_info, parent, parent_arg_info); - - if (check < 0) { - _inheritance_runtime_error_msg(child, parent); + if (status == INHERITANCE_UNRESOLVED) { + inheritance_runtime_error_msg(child, parent); continue; } } From 44e3a3206370557ba177a5ab8e755200ef7de580 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Wed, 27 Mar 2019 10:33:42 +0100 Subject: [PATCH 17/19] Add failing test for runtime variance fail --- .../variance/runtime_fail.phpt | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 Zend/tests/type_declarations/variance/runtime_fail.phpt diff --git a/Zend/tests/type_declarations/variance/runtime_fail.phpt b/Zend/tests/type_declarations/variance/runtime_fail.phpt new file mode 100644 index 0000000000000..d9b4bde12fba3 --- /dev/null +++ b/Zend/tests/type_declarations/variance/runtime_fail.phpt @@ -0,0 +1,20 @@ +--TEST-- +Classes do not exist at compile-time and have incorrect variance at runtime +--FILE-- + +--EXPECT-- +Should fail. From 01af74ceee7328c48e18c9f2ae681d99b1c0567e Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Wed, 27 Mar 2019 11:04:33 +0100 Subject: [PATCH 18/19] Delay LSP warnings until runtime --- .../variance/parent_in_class.phpt | 4 +- .../variance/runtime_fail.phpt | 4 +- Zend/zend_inheritance.c | 73 ++++++++++--------- 3 files changed, 43 insertions(+), 38 deletions(-) diff --git a/Zend/tests/type_declarations/variance/parent_in_class.phpt b/Zend/tests/type_declarations/variance/parent_in_class.phpt index c527d7dcf98da..fe5113b6a397d 100644 --- a/Zend/tests/type_declarations/variance/parent_in_class.phpt +++ b/Zend/tests/type_declarations/variance/parent_in_class.phpt @@ -40,6 +40,6 @@ class B4 extends A4 { ?> --EXPECTF-- -Warning: Declaration of B4::method(A4 $x) should be compatible with A4::method(P4 $x) in %s on line 35 - Warning: Declaration of B::method(A $x) should be compatible with A::method(parent $x) in %s on line 8 + +Warning: Declaration of B4::method(A4 $x) should be compatible with A4::method(P4 $x) in %s on line 35 diff --git a/Zend/tests/type_declarations/variance/runtime_fail.phpt b/Zend/tests/type_declarations/variance/runtime_fail.phpt index d9b4bde12fba3..6f15ac46dca86 100644 --- a/Zend/tests/type_declarations/variance/runtime_fail.phpt +++ b/Zend/tests/type_declarations/variance/runtime_fail.phpt @@ -16,5 +16,5 @@ class B extends A { } ?> ---EXPECT-- -Should fail. +--EXPECTF-- +Fatal error: Declaration of B::method(): Y must be compatible with A::method(): X in %s on line 12 diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index 40b68c171232c..5a1e023c3c260 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -478,14 +478,6 @@ static inheritance_status zend_do_perform_implementation_check( } } - /* - if (status == INHERITANCE_UNRESOLVED && CG(unverified_types)) { - zend_string *key = zend_string_tolower(fe->common.scope->name); - zend_hash_add_empty_element(CG(unverified_types), key); - zend_string_release(key); - } - */ - return status; } /* }}} */ @@ -651,6 +643,21 @@ static ZEND_COLD zend_string *zend_get_function_declaration(const zend_function } /* }}} */ +static zend_bool lsp_fail_is_error(zend_function *child, zend_function *parent) { + /* Failed verification against abstract method, error. */ + if (child->common.prototype && (child->common.prototype->common.fn_flags & ZEND_ACC_ABSTRACT)) { + return 1; + } + /* Failed return type verification, error. */ + if ((parent->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) && + !check_inherited_return_type(child, child->common.arg_info - 1, parent, parent->common.arg_info - 1)) { + return 1; + } + + /* Legacy: Parameter verification failures against non-abstract methods are only warnings. */ + return 0; +} + static zend_always_inline uint32_t func_lineno(zend_function *fn) { return fn->common.type == ZEND_USER_FUNCTION ? fn->op_array.line_start : 0; } @@ -737,31 +744,31 @@ static void do_inheritance_check_on_method(zend_function *child, zend_function * ZEND_FN_SCOPE_NAME(child), ZSTR_VAL(child->common.function_name), zend_visibility_string(parent_flags), ZEND_FN_SCOPE_NAME(parent), (parent_flags&ZEND_ACC_PUBLIC) ? "" : " or weaker"); } - if (UNEXPECTED(zend_do_perform_implementation_check(child, parent)) == INHERITANCE_ERROR) { - int error_level; - const char *error_verb; - zend_string *method_prototype = zend_get_function_declaration(parent); - zend_string *child_prototype = zend_get_function_declaration(child); - - if (child->common.prototype && ( - child->common.prototype->common.fn_flags & ZEND_ACC_ABSTRACT - )) { - error_level = E_COMPILE_ERROR; - error_verb = "must"; - } else if ((parent->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) && - !check_inherited_return_type(child, child->common.arg_info - 1, parent, parent->common.arg_info - 1)) { - error_level = E_COMPILE_ERROR; - error_verb = "must"; + inheritance_status status = zend_do_perform_implementation_check(child, parent); + if (UNEXPECTED(status == INHERITANCE_ERROR)) { + if (lsp_fail_is_error(child, parent)) { + zend_string *method_prototype = zend_get_function_declaration(parent); + zend_string *child_prototype = zend_get_function_declaration(child); + zend_error_at(E_COMPILE_ERROR, NULL, func_lineno(child), + "Declaration of %s must be compatible with %s", + ZSTR_VAL(child_prototype), ZSTR_VAL(method_prototype)); + zend_string_efree(child_prototype); + zend_string_efree(method_prototype); } else { - error_level = E_WARNING; - error_verb = "should"; + /* Delay this warning until runtime, to avoid duplicate warnings. */ + status = INHERITANCE_UNRESOLVED; } - zend_error_at(error_level, NULL, func_lineno(child), - "Declaration of %s %s be compatible with %s", - ZSTR_VAL(child_prototype), error_verb, ZSTR_VAL(method_prototype)); - zend_string_efree(child_prototype); - zend_string_efree(method_prototype); } + + /* TODO Properly handle UNRESOLVED. */ + + /* + if (status == INHERITANCE_UNRESOLVED && CG(unverified_types)) { + zend_string *key = zend_string_tolower(fe->common.scope->name); + zend_hash_add_empty_element(CG(unverified_types), key); + zend_string_release(key); + } + */ } } while (0); } @@ -2256,9 +2263,7 @@ ZEND_API void zend_verify_variance(zend_class_entry *ce) inheritance_status status = check_inherited_return_type( child, &child->common.arg_info[-1], parent, &parent->common.arg_info[-1]); - /* TODO I don't think this is right -- what if the class now exists - * but has wrong variance? */ - if (status == INHERITANCE_UNRESOLVED) { + if (status != INHERITANCE_SUCCESS) { inheritance_runtime_error_msg(child, parent); continue; } @@ -2295,7 +2300,7 @@ ZEND_API void zend_verify_variance(zend_class_entry *ce) inheritance_status status = check_inherited_parameter_type( child, child_arg_info, parent, parent_arg_info); - if (status == INHERITANCE_UNRESOLVED) { + if (status != INHERITANCE_SUCCESS) { inheritance_runtime_error_msg(child, parent); continue; } From c454a3ba64e4a8cbedccd49203f316927bda203f Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Wed, 27 Mar 2019 12:11:49 +0100 Subject: [PATCH 19/19] Perform full implementation check at runtime --- .../variance/enum_forward_compat.phpt | 2 +- Zend/zend_inheritance.c | 85 ++----------------- 2 files changed, 7 insertions(+), 80 deletions(-) diff --git a/Zend/tests/type_declarations/variance/enum_forward_compat.phpt b/Zend/tests/type_declarations/variance/enum_forward_compat.phpt index a183d0786a641..3213aaaf76bd4 100644 --- a/Zend/tests/type_declarations/variance/enum_forward_compat.phpt +++ b/Zend/tests/type_declarations/variance/enum_forward_compat.phpt @@ -22,5 +22,5 @@ class B extends A { ?> --EXPECT-- -string(1) "Y" string(1) "X" +string(1) "Y" diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index 5a1e023c3c260..c2adde3d0c1ab 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -760,15 +760,11 @@ static void do_inheritance_check_on_method(zend_function *child, zend_function * } } - /* TODO Properly handle UNRESOLVED. */ - - /* - if (status == INHERITANCE_UNRESOLVED && CG(unverified_types)) { - zend_string *key = zend_string_tolower(fe->common.scope->name); + if (status == INHERITANCE_UNRESOLVED && CG(unverified_types)) { + zend_string *key = zend_string_tolower(child->common.scope->name); zend_hash_add_empty_element(CG(unverified_types), key); zend_string_release(key); - } - */ + } } } while (0); } @@ -2222,9 +2218,8 @@ ZEND_API void zend_verify_variance(zend_class_entry *ce) ZEND_ASSERT(ce->ce_flags & ZEND_ACC_LINKED); ZEND_HASH_FOREACH_PTR(&ce->function_table, child) { - zend_function *parent = child->common.prototype; - /* Methods without prototypes do not need checked for variance. */ + zend_function *parent = child->common.prototype; if (!parent) { continue; } @@ -2236,76 +2231,8 @@ ZEND_API void zend_verify_variance(zend_class_entry *ce) continue; } - /* We are only willing to ignore this for internal functions because - * extensions don't always define arg_info. */ - if (missing_internal_arginfo(parent)) { - continue; - } - - /* If the parenttype method is private do not enforce a signature */ - if (!(parent->common.fn_flags & ZEND_ACC_PRIVATE)) { - uint32_t i, num_args; - - /* Checks for constructors only if they are declared in an interface, - * or explicitly marked as abstract - */ - if ((ce->constructor == child) - && ((parent->common.scope->ce_flags & ZEND_ACC_INTERFACE) == 0 - && (parent->common.fn_flags & ZEND_ACC_ABSTRACT) == 0)) - { - continue; - } - - /* Check return type compatibility, but only if the prototype already - * specifies a return type. Adding a new return type is always valid. */ - if (parent->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) { - if (child->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) { - inheritance_status status = check_inherited_return_type( - child, &child->common.arg_info[-1], - parent, &parent->common.arg_info[-1]); - if (status != INHERITANCE_SUCCESS) { - inheritance_runtime_error_msg(child, parent); - continue; - } - } else { - // This branch should already have been taken care of - continue; - } - } - - if (parent->common.required_num_args < child->common.required_num_args - || parent->common.num_args > child->common.num_args) - { - // This branch should already have been taken care of - continue; - } - - num_args = parent->common.num_args; - if (parent->common.fn_flags & ZEND_ACC_VARIADIC) { - num_args++; - if (child->common.num_args >= parent->common.num_args) { - num_args = child->common.num_args; - if (child->common.fn_flags & ZEND_ACC_VARIADIC) { - num_args++; - } - } - } - - for (i = 0; i < num_args; i++) { - zend_arg_info *child_arg_info = &child->common.arg_info[i]; - zend_arg_info *parent_arg_info = (i < parent->common.num_args) - ? &parent->common.arg_info[i] - : &parent->common.arg_info[parent->common.num_args]; - - inheritance_status status = check_inherited_parameter_type( - child, child_arg_info, - parent, parent_arg_info); - if (status != INHERITANCE_SUCCESS) { - inheritance_runtime_error_msg(child, parent); - continue; - } - } - + if (zend_do_perform_implementation_check(child, parent) != INHERITANCE_SUCCESS) { + inheritance_runtime_error_msg(child, parent); } } ZEND_HASH_FOREACH_END();