From 0b31517e799965a4b86042a6399a61ac19d1c859 Mon Sep 17 00:00:00 2001 From: Levi Morrison Date: Sat, 21 Jul 2018 17:21:01 -0600 Subject: [PATCH 1/5] 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 | 7 +- Zend/tests/return_types/generators003.phpt | 7 +- Zend/tests/return_types/inheritance005.phpt | 7 +- Zend/tests/return_types/inheritance006.phpt | 7 +- Zend/tests/return_types/inheritance007.phpt | 7 +- ...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 | 125 +- 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 | 1829 +++++++++-------- Zend/zend_vm_opcodes.c | 4 +- Zend/zend_vm_opcodes.h | 1 + 22 files changed, 1593 insertions(+), 1135 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 f2e01299de2fb..5a4075c00c85e 100644 --- a/Zend/tests/return_types/008.phpt +++ b/Zend/tests/return_types/008.phpt @@ -14,6 +14,7 @@ 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 7 +echo get_class($qux->bar()); + +--EXPECT-- +qux diff --git a/Zend/tests/return_types/generators003.phpt b/Zend/tests/return_types/generators003.phpt index 5502318e982a6..ae3dfca59a15e 100644 --- a/Zend/tests/return_types/generators003.phpt +++ b/Zend/tests/return_types/generators003.phpt @@ -15,6 +15,7 @@ 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 6 +echo get_class($some->getIterator()); + +--EXPECT-- +Generator diff --git a/Zend/tests/return_types/inheritance005.phpt b/Zend/tests/return_types/inheritance005.phpt index 7415a72b9f591..b3908c5875205 100644 --- a/Zend/tests/return_types/inheritance005.phpt +++ b/Zend/tests/return_types/inheritance005.phpt @@ -13,5 +13,8 @@ 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 12 + +echo get_class(Bar::test()); + +--EXPECT-- +Bar diff --git a/Zend/tests/return_types/inheritance006.phpt b/Zend/tests/return_types/inheritance006.phpt index 7d4bcbe57b008..49290b1b4cf9e 100644 --- a/Zend/tests/return_types/inheritance006.phpt +++ b/Zend/tests/return_types/inheritance006.phpt @@ -17,5 +17,8 @@ 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 14 + +echo get_class(Bar::test()); + +--EXPECT-- +B diff --git a/Zend/tests/return_types/inheritance007.phpt b/Zend/tests/return_types/inheritance007.phpt index af1738f807692..ce965929a25fb 100644 --- a/Zend/tests/return_types/inheritance007.phpt +++ b/Zend/tests/return_types/inheritance007.phpt @@ -15,5 +15,8 @@ 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 12 + +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 3619a7808d22e..9660cba7bac79 100644 --- a/Zend/zend.c +++ b/Zend/zend.c @@ -627,6 +627,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 a6fe6954b7b4c..51abf0fcf9ace 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -3959,6 +3959,27 @@ void zend_compile_static_call(znode *result, zend_ast *ast, uint32_t type) /* {{ } /* }}} */ + +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_class_decl(zend_ast *ast, zend_bool toplevel); void zend_compile_new(znode *result, zend_ast *ast) /* {{{ */ @@ -3970,16 +3991,29 @@ void zend_compile_new(znode *result, zend_ast *ast) /* {{{ */ zend_op *opline; if (class_ast->kind == ZEND_AST_CLASS) { - uint32_t dcl_opnum = get_next_op_number(); - zend_compile_class_decl(class_ast, 0); - /* jump over anon class declaration */ - opline = &CG(active_op_array)->opcodes[dcl_opnum]; - if (opline->opcode == ZEND_FETCH_CLASS) { - opline++; - } - class_node.op_type = opline->result_type; - class_node.u.op.var = opline->result.var; - opline->extended_value = get_next_op_number(); + /* 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); + + { + uint32_t dcl_opnum = get_next_op_number(); + zend_compile_class_decl(class_ast, 0); + /* jump over anon class declaration */ + opline = &CG(active_op_array)->opcodes[dcl_opnum]; + if (opline->opcode == ZEND_FETCH_CLASS) { + opline++; + } + 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); } @@ -6290,6 +6324,14 @@ void 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))) { @@ -8088,6 +8130,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) /* {{{ */ { @@ -8097,9 +8168,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 d558fa9ad8518..2fa21c6c38468 100644 --- a/Zend/zend_globals.h +++ b/Zend/zend_globals.h @@ -65,6 +65,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 9dc26088f76bc..790dd531a1ae2 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" @@ -177,72 +178,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; @@ -253,11 +382,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; @@ -265,7 +394,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; } @@ -307,7 +436,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++; @@ -317,35 +446,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; } } @@ -353,27 +458,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; } @@ -624,9 +710,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 { @@ -2044,6 +2128,119 @@ 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) +{ + 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(); + +} +/* }}} */ + /* * Local variables: * tab-width: 4 diff --git a/Zend/zend_inheritance.h b/Zend/zend_inheritance.h index a882f6461f069..ce9d4f058729f 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 e03133d2da8b0..4bdb863586fcc 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -6941,6 +6941,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 e00beafc255ff..83eb38c4c1130 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -9902,6 +9902,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +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 @@ -59454,6 +59470,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, @@ -62625,6 +62642,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_UNUSED) ZEND_ISSET_ISEMPTY_STATIC_PROP_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); @@ -70662,6 +70683,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, @@ -72713,71 +72735,71 @@ void zend_vm_init(void) 2705, 2706 | SPEC_RULE_OP1, 2711, - 4617, + 4618, 2712, - 4617, - 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, - 4617, - 4617, + 2866, + 2867 | SPEC_RULE_OP1, 2872, + 4618, + 4618, 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 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3268 | SPEC_RULE_OP1, - 3273, + 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 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 3269 | SPEC_RULE_OP1, 3274, 3275, 3276, 3277, - 3278 | SPEC_RULE_OP1, - 3283 | SPEC_RULE_OP1, - 3288 | SPEC_RULE_OP1, - 3293 | SPEC_RULE_OP1, - 3298 | SPEC_RULE_OP1, - 3303, - 3304 | SPEC_RULE_OP1, - 3309, - 3310 | SPEC_RULE_OP1, - 3315, - 3316 | SPEC_RULE_ISSET, - 3318 | SPEC_RULE_OP2, - 3323 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3348 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA, - 3473 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA, - 3598 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3623 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3648 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3673 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3698 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3723, - 4617 + 3278, + 3279 | SPEC_RULE_OP1, + 3284 | SPEC_RULE_OP1, + 3289 | SPEC_RULE_OP1, + 3294 | SPEC_RULE_OP1, + 3299 | SPEC_RULE_OP1, + 3304, + 3305 | SPEC_RULE_OP1, + 3310, + 3311 | SPEC_RULE_OP1, + 3316, + 3317 | SPEC_RULE_ISSET, + 3319 | SPEC_RULE_OP2, + 3324 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 3349 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA, + 3474 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA, + 3599 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 3624 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 3649 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 3674 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 3699 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 3724, + 4618 }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -72982,7 +73004,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 = 3725 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3726 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -72990,7 +73012,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 = 3750 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3751 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -72998,7 +73020,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 = 3775 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3776 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -73009,17 +73031,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 = 3800 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3801 | 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 = 3825 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3826 | 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 = 3850 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3851 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -73030,17 +73052,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 = 3875 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3876 | 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 = 3900 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3901 | 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 = 3925 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3926 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -73051,12 +73073,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 = 3950 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3951 | 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 = 4025 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 4026 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -73067,12 +73089,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 = 4100 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 4101 | 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 = 4175 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 4176 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -73080,12 +73102,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 = 4250 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 4251 | 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 = 4325 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 4326 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -73093,75 +73115,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 = 4400 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 4401 | 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 = 4475 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 4476 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_DOUBLE) { - spec = 4568 | SPEC_RULE_OP1; + spec = 4569 | 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 = 4573 | SPEC_RULE_OP1; + spec = 4574 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 4550 | SPEC_RULE_RETVAL; + spec = 4551 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 4552 | SPEC_RULE_RETVAL; + spec = 4553 | SPEC_RULE_RETVAL; } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) { - spec = 4554 | SPEC_RULE_RETVAL; + spec = 4555 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 4556 | SPEC_RULE_RETVAL; + spec = 4557 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 4558 | SPEC_RULE_RETVAL; + spec = 4559 | SPEC_RULE_RETVAL; } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) { - spec = 4560 | SPEC_RULE_RETVAL; + spec = 4561 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 4562; - } else if (op1_info == MAY_BE_LONG) { spec = 4563; - } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) { + } else if (op1_info == MAY_BE_LONG) { spec = 4564; + } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) { + spec = 4565; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 4565; - } else if (op1_info == MAY_BE_LONG) { spec = 4566; - } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) { + } else if (op1_info == MAY_BE_LONG) { spec = 4567; + } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) { + spec = 4568; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 3724; + spec = 3725; } break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 4613; + spec = 4614; } break; case ZEND_SEND_VAR_EX: if (op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 4608 | SPEC_RULE_OP1; + spec = 4609 | 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 = 4615 | SPEC_RULE_RETVAL; + spec = 4616 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -73169,17 +73191,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 = 4578 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 4579 | 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 = 4614; + spec = 4615; } break; case ZEND_SEND_VAR: if ((op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 4603 | SPEC_RULE_OP1; + spec = 4604 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 4dd164f17c182..3cee5111f1f99 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -1423,974 +1423,975 @@ _(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_CONST_CONST) \ - _(3245, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_VAR) \ - _(3246, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_UNUSED) \ - _(3248, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_CONST) \ - _(3250, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_VAR) \ - _(3251, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ - _(3253, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_CONST) \ - _(3255, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_VAR) \ - _(3256, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ - _(3263, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_CONST) \ - _(3265, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_VAR) \ - _(3266, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_UNUSED) \ - _(3268, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ - _(3270, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ - _(3271, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ - _(3273, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ - _(3274, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \ - _(3275, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ - _(3276, ZEND_SEND_FUNC_ARG_SPEC_VAR) \ - _(3277, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ - _(3278, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ - _(3279, 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_CONST_CONST) \ + _(3246, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_VAR) \ + _(3247, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_UNUSED) \ + _(3249, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_CONST) \ + _(3251, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_VAR) \ + _(3252, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ + _(3254, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_CONST) \ + _(3256, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_VAR) \ + _(3257, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ + _(3264, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_CONST) \ + _(3266, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_VAR) \ + _(3267, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_UNUSED) \ + _(3269, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ + _(3271, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ + _(3272, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ + _(3274, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ + _(3275, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \ + _(3276, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ + _(3277, ZEND_SEND_FUNC_ARG_SPEC_VAR) \ + _(3278, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ + _(3279, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ _(3280, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(3282, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(3283, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ - _(3284, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(3281, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(3283, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(3284, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ _(3285, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(3287, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(3288, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ - _(3289, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ - _(3290, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ - _(3292, ZEND_IN_ARRAY_SPEC_CV_CONST) \ - _(3293, ZEND_COUNT_SPEC_CONST_UNUSED) \ - _(3294, ZEND_COUNT_SPEC_TMP_UNUSED) \ - _(3295, ZEND_COUNT_SPEC_VAR_UNUSED) \ - _(3297, ZEND_COUNT_SPEC_CV_UNUSED) \ - _(3298, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ - _(3299, ZEND_GET_CLASS_SPEC_TMP_UNUSED) \ - _(3300, ZEND_GET_CLASS_SPEC_VAR_UNUSED) \ - _(3301, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ - _(3302, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ - _(3303, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ - _(3304, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ - _(3305, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ - _(3306, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ - _(3308, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ - _(3309, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ - _(3310, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ - _(3313, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ - _(3315, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ - _(3316, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ - _(3317, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ - _(3318, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ - _(3319, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ + _(3286, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(3288, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(3289, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ + _(3290, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ + _(3291, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ + _(3293, ZEND_IN_ARRAY_SPEC_CV_CONST) \ + _(3294, ZEND_COUNT_SPEC_CONST_UNUSED) \ + _(3295, ZEND_COUNT_SPEC_TMP_UNUSED) \ + _(3296, ZEND_COUNT_SPEC_VAR_UNUSED) \ + _(3298, ZEND_COUNT_SPEC_CV_UNUSED) \ + _(3299, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ + _(3300, ZEND_GET_CLASS_SPEC_TMP_UNUSED) \ + _(3301, ZEND_GET_CLASS_SPEC_VAR_UNUSED) \ + _(3302, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ + _(3303, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ + _(3304, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ + _(3305, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ + _(3306, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ + _(3307, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ + _(3309, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ + _(3310, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ + _(3311, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ + _(3314, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ + _(3316, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ + _(3317, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ + _(3318, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ + _(3319, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ _(3320, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ - _(3322, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ - _(3323, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ - _(3324, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ + _(3321, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ + _(3323, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ + _(3324, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ _(3325, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ - _(3327, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ - _(3328, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ - _(3329, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(3326, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ + _(3328, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ + _(3329, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ _(3330, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(3332, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(3333, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ - _(3334, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(3331, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(3333, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(3334, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ _(3335, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(3337, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(3343, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ - _(3344, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ + _(3336, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(3338, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(3344, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ _(3345, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ - _(3347, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ - _(3400, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR) \ - _(3402, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV) \ - _(3405, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ - _(3407, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV) \ - _(3410, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ - _(3412, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV) \ - _(3420, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR) \ - _(3422, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV) \ - _(3425, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR) \ - _(3427, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV) \ - _(3430, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) \ - _(3432, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV) \ - _(3435, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) \ - _(3437, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV) \ - _(3445, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR) \ - _(3447, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV) \ - _(3450, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR) \ - _(3452, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV) \ - _(3455, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR) \ - _(3457, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV) \ - _(3460, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR) \ - _(3462, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV) \ - _(3470, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR) \ - _(3472, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV) \ - _(3473, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_CONST) \ - _(3474, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_TMP) \ - _(3475, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_VAR) \ - _(3477, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_CV) \ - _(3483, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_CONST) \ - _(3484, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_TMP) \ - _(3485, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_VAR) \ - _(3487, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_CV) \ - _(3488, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_CONST) \ - _(3489, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_TMP) \ - _(3490, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_VAR) \ - _(3492, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_CV) \ - _(3498, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CONST) \ - _(3499, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_TMP) \ - _(3500, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_VAR) \ - _(3502, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CV) \ - _(3508, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CONST) \ - _(3509, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_TMP) \ - _(3510, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_VAR) \ - _(3512, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CV) \ - _(3513, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CONST) \ - _(3514, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_TMP) \ - _(3515, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_VAR) \ - _(3517, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CV) \ - _(3523, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CONST) \ - _(3524, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_TMP) \ - _(3525, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_VAR) \ - _(3527, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CV) \ - _(3533, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CONST) \ - _(3534, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_TMP) \ - _(3535, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_VAR) \ - _(3537, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CV) \ - _(3538, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CONST) \ - _(3539, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_TMP) \ - _(3540, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_VAR) \ - _(3542, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CV) \ - _(3573, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_CONST) \ - _(3574, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_TMP) \ - _(3575, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_VAR) \ - _(3577, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_CV) \ - _(3583, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_CONST) \ - _(3584, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_TMP) \ - _(3585, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_VAR) \ - _(3587, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_CV) \ - _(3588, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_CONST) \ - _(3589, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_TMP) \ - _(3590, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_VAR) \ - _(3592, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_CV) \ - _(3598, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_CONST) \ - _(3600, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_VAR) \ - _(3601, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_UNUSED) \ - _(3603, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_CONST) \ - _(3605, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_VAR) \ - _(3606, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_UNUSED) \ - _(3608, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_CONST) \ - _(3610, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_VAR) \ - _(3611, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_UNUSED) \ - _(3618, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_CONST) \ - _(3620, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_VAR) \ - _(3621, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_UNUSED) \ - _(3623, ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_CONST) \ - _(3625, ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_VAR) \ - _(3626, ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_UNUSED) \ - _(3628, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_CONST) \ - _(3630, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_VAR) \ - _(3631, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ - _(3633, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_CONST) \ - _(3635, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_VAR) \ - _(3636, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ - _(3643, ZEND_PRE_INC_STATIC_PROP_SPEC_CV_CONST) \ - _(3645, ZEND_PRE_INC_STATIC_PROP_SPEC_CV_VAR) \ - _(3646, ZEND_PRE_INC_STATIC_PROP_SPEC_CV_UNUSED) \ - _(3648, ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_CONST) \ - _(3650, ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_VAR) \ - _(3651, ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_UNUSED) \ - _(3653, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_CONST) \ - _(3655, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_VAR) \ - _(3656, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ - _(3658, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_CONST) \ - _(3660, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_VAR) \ - _(3661, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ - _(3668, ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_CONST) \ - _(3670, ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_VAR) \ - _(3671, ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_UNUSED) \ - _(3673, ZEND_POST_INC_STATIC_PROP_SPEC_CONST_CONST) \ - _(3675, ZEND_POST_INC_STATIC_PROP_SPEC_CONST_VAR) \ - _(3676, ZEND_POST_INC_STATIC_PROP_SPEC_CONST_UNUSED) \ - _(3678, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_CONST) \ - _(3680, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_VAR) \ - _(3681, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ - _(3683, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_CONST) \ - _(3685, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_VAR) \ - _(3686, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ - _(3693, ZEND_POST_INC_STATIC_PROP_SPEC_CV_CONST) \ - _(3695, ZEND_POST_INC_STATIC_PROP_SPEC_CV_VAR) \ - _(3696, ZEND_POST_INC_STATIC_PROP_SPEC_CV_UNUSED) \ - _(3698, ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_CONST) \ - _(3700, ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_VAR) \ - _(3701, ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_UNUSED) \ - _(3703, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_CONST) \ - _(3705, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_VAR) \ - _(3706, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ - _(3708, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_CONST) \ - _(3710, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_VAR) \ - _(3711, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ - _(3718, ZEND_POST_DEC_STATIC_PROP_SPEC_CV_CONST) \ - _(3720, ZEND_POST_DEC_STATIC_PROP_SPEC_CV_VAR) \ - _(3721, ZEND_POST_DEC_STATIC_PROP_SPEC_CV_UNUSED) \ - _(3723, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ - _(3724, ZEND_JMP_FORWARD_SPEC) \ - _(3730, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3731, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3346, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ + _(3348, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ + _(3401, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR) \ + _(3403, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV) \ + _(3406, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ + _(3408, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV) \ + _(3411, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ + _(3413, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV) \ + _(3421, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR) \ + _(3423, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV) \ + _(3426, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR) \ + _(3428, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV) \ + _(3431, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) \ + _(3433, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV) \ + _(3436, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) \ + _(3438, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV) \ + _(3446, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR) \ + _(3448, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV) \ + _(3451, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR) \ + _(3453, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV) \ + _(3456, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR) \ + _(3458, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV) \ + _(3461, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR) \ + _(3463, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV) \ + _(3471, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR) \ + _(3473, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV) \ + _(3474, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_CONST) \ + _(3475, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_TMP) \ + _(3476, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_VAR) \ + _(3478, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_CV) \ + _(3484, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_CONST) \ + _(3485, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_TMP) \ + _(3486, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_VAR) \ + _(3488, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_CV) \ + _(3489, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_CONST) \ + _(3490, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_TMP) \ + _(3491, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_VAR) \ + _(3493, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_CV) \ + _(3499, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CONST) \ + _(3500, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_TMP) \ + _(3501, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_VAR) \ + _(3503, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CV) \ + _(3509, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CONST) \ + _(3510, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_TMP) \ + _(3511, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_VAR) \ + _(3513, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CV) \ + _(3514, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CONST) \ + _(3515, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_TMP) \ + _(3516, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_VAR) \ + _(3518, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CV) \ + _(3524, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CONST) \ + _(3525, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_TMP) \ + _(3526, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_VAR) \ + _(3528, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CV) \ + _(3534, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CONST) \ + _(3535, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_TMP) \ + _(3536, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_VAR) \ + _(3538, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CV) \ + _(3539, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CONST) \ + _(3540, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_TMP) \ + _(3541, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_VAR) \ + _(3543, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CV) \ + _(3574, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_CONST) \ + _(3575, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_TMP) \ + _(3576, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_VAR) \ + _(3578, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_CV) \ + _(3584, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_CONST) \ + _(3585, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_TMP) \ + _(3586, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_VAR) \ + _(3588, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_CV) \ + _(3589, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_CONST) \ + _(3590, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_TMP) \ + _(3591, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_VAR) \ + _(3593, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_CV) \ + _(3599, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_CONST) \ + _(3601, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_VAR) \ + _(3602, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_UNUSED) \ + _(3604, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_CONST) \ + _(3606, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_VAR) \ + _(3607, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_UNUSED) \ + _(3609, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_CONST) \ + _(3611, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_VAR) \ + _(3612, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_UNUSED) \ + _(3619, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_CONST) \ + _(3621, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_VAR) \ + _(3622, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_UNUSED) \ + _(3624, ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_CONST) \ + _(3626, ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_VAR) \ + _(3627, ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_UNUSED) \ + _(3629, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_CONST) \ + _(3631, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_VAR) \ + _(3632, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ + _(3634, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_CONST) \ + _(3636, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_VAR) \ + _(3637, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ + _(3644, ZEND_PRE_INC_STATIC_PROP_SPEC_CV_CONST) \ + _(3646, ZEND_PRE_INC_STATIC_PROP_SPEC_CV_VAR) \ + _(3647, ZEND_PRE_INC_STATIC_PROP_SPEC_CV_UNUSED) \ + _(3649, ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_CONST) \ + _(3651, ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_VAR) \ + _(3652, ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_UNUSED) \ + _(3654, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_CONST) \ + _(3656, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_VAR) \ + _(3657, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ + _(3659, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_CONST) \ + _(3661, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_VAR) \ + _(3662, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ + _(3669, ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_CONST) \ + _(3671, ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_VAR) \ + _(3672, ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_UNUSED) \ + _(3674, ZEND_POST_INC_STATIC_PROP_SPEC_CONST_CONST) \ + _(3676, ZEND_POST_INC_STATIC_PROP_SPEC_CONST_VAR) \ + _(3677, ZEND_POST_INC_STATIC_PROP_SPEC_CONST_UNUSED) \ + _(3679, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_CONST) \ + _(3681, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_VAR) \ + _(3682, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ + _(3684, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_CONST) \ + _(3686, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_VAR) \ + _(3687, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ + _(3694, ZEND_POST_INC_STATIC_PROP_SPEC_CV_CONST) \ + _(3696, ZEND_POST_INC_STATIC_PROP_SPEC_CV_VAR) \ + _(3697, ZEND_POST_INC_STATIC_PROP_SPEC_CV_UNUSED) \ + _(3699, ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_CONST) \ + _(3701, ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_VAR) \ + _(3702, ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_UNUSED) \ + _(3704, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_CONST) \ + _(3706, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_VAR) \ + _(3707, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ + _(3709, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_CONST) \ + _(3711, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_VAR) \ + _(3712, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ + _(3719, ZEND_POST_DEC_STATIC_PROP_SPEC_CV_CONST) \ + _(3721, ZEND_POST_DEC_STATIC_PROP_SPEC_CV_VAR) \ + _(3722, ZEND_POST_DEC_STATIC_PROP_SPEC_CV_UNUSED) \ + _(3724, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ + _(3725, ZEND_JMP_FORWARD_SPEC) \ + _(3731, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3732, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3734, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3735, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3736, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3733, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3735, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3736, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3737, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3739, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3745, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3746, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3738, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3740, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3746, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3747, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3749, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3755, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(3756, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3748, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3750, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3756, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(3757, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3759, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3760, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(3761, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3758, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3760, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3761, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(3762, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3764, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3770, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(3771, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3763, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3765, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3771, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(3772, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3774, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3780, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3781, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3773, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3775, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3781, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3782, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3784, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3785, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3786, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3783, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3785, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3786, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3787, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3789, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3795, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3796, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3788, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3790, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3796, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3797, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3799, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3801, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(3798, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3800, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3802, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(3804, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(3805, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3806, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3803, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(3805, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(3806, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3807, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3809, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3810, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3811, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3808, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3810, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3811, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3812, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3814, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3820, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3821, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3813, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3815, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3821, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3822, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3824, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3826, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(3823, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3825, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(3827, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(3829, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(3830, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(3831, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3828, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(3830, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(3831, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(3832, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3834, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3835, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(3836, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3833, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3835, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3836, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(3837, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3839, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3845, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(3846, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3838, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3840, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3846, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(3847, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3849, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3851, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3848, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3850, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(3852, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3854, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3855, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3856, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3853, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3855, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3856, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3857, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3859, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3860, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3861, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3858, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3860, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3861, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3862, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3864, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3870, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3871, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3863, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3865, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3871, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3872, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3874, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3880, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3881, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3873, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3875, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3881, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3882, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3884, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3885, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3886, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3883, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3885, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3886, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3887, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3889, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3895, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3896, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3888, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3890, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3896, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3897, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3899, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3905, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(3906, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3898, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3900, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3906, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(3907, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3909, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3910, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(3911, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3908, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3910, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3911, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(3912, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3914, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3920, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(3921, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3913, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3915, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3921, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(3922, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3924, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3930, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3931, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3923, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3925, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3931, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3932, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3934, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3935, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3936, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3933, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3935, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3936, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3937, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3939, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3945, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3946, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3938, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3940, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3946, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3947, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3949, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3965, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3966, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3967, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3968, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3969, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3970, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3971, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3972, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3973, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3977, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3978, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3979, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3980, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3981, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3982, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3983, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3984, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3985, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3986, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3987, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3988, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3992, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3993, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3994, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4010, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(4011, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4012, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4013, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4014, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4015, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4016, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4017, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4018, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4022, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4023, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4024, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4040, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(4041, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4042, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4043, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4044, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4045, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4046, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4047, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4048, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4052, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4053, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4054, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4055, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(4056, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4057, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4058, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4059, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4060, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4061, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4062, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4063, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4067, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4068, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4069, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4085, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(4086, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4087, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4088, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4089, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4090, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4091, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4092, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4093, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4097, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4098, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4099, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4115, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(4116, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4117, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4118, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4119, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4120, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4121, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4122, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4123, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4127, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4128, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4129, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4130, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(4131, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4132, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4133, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4134, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4135, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4136, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4137, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4138, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4142, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4143, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4144, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4160, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(4161, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4162, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4163, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4164, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4165, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4166, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4167, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4168, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4172, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4173, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4174, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4190, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(4191, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4192, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4193, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4194, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4195, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4196, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4197, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4198, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4202, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4203, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4204, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4205, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(4206, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4207, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4208, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4209, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4210, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4211, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4212, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4213, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4217, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4218, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4219, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4235, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(4236, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4237, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4238, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4239, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4240, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4241, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4242, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4243, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4247, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4248, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4249, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4253, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(4254, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4255, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4256, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(4257, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4258, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4262, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(4263, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4264, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4265, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(4266, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4267, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4268, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4269, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4270, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4271, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4272, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4273, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4277, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4278, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4279, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4280, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(4281, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4282, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4283, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4284, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4285, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4286, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4287, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4288, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4292, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4293, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4294, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4310, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(4311, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4312, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4313, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4314, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4315, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4316, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4317, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4318, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4322, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4323, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4324, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4328, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(4329, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4330, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4331, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(4332, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4333, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4337, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(4338, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4339, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4340, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(4341, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4342, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4343, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4344, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4345, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4346, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4347, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4348, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4352, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4353, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4354, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4355, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(4356, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4357, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4358, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4359, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4360, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4361, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4362, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4363, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4367, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4368, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4369, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4385, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(4386, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4387, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4388, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4389, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4390, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4391, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4392, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4393, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4397, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4398, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4399, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4403, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(4404, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4405, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4406, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(4407, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4408, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4412, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(4413, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4414, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4415, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(4416, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4417, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4418, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4419, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4420, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4421, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4422, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4423, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4427, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4428, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4429, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4430, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(4431, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4432, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4433, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4434, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4435, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4436, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4437, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4438, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4442, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4443, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4444, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4460, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(4461, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4462, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4463, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4464, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4465, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4466, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4467, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4468, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4472, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(4473, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4474, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4478, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(4479, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4480, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4481, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(4482, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4483, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4487, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(4488, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(4489, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(4490, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(4491, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4492, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4493, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4494, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4495, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4496, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4497, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4498, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4502, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4503, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4504, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4505, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(4506, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4507, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4508, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4509, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4510, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4511, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4512, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4513, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4517, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4518, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4519, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4535, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(4536, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(4537, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(4538, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4539, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4540, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4541, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4542, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4543, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4547, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(4548, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(4549, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(4550, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \ - _(4551, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \ - _(4552, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \ - _(4553, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED) \ - _(4554, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \ - _(4555, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \ - _(4556, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \ - _(4557, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \ - _(4558, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \ - _(4559, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED) \ - _(4560, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \ - _(4561, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \ - _(4562, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \ - _(4563, ZEND_POST_INC_LONG_SPEC_TMPVARCV) \ - _(4564, ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \ - _(4565, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \ - _(4566, ZEND_POST_DEC_LONG_SPEC_TMPVARCV) \ - _(4567, ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \ - _(4568, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(4569, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3948, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3950, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3966, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3967, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3968, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3969, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3970, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3971, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3972, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3973, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3974, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3978, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3979, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3980, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3981, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3982, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3983, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3984, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3985, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3986, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3987, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3988, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3989, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3993, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3994, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3995, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4011, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(4012, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4013, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4014, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4015, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4016, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4017, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4018, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4019, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4023, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4024, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4025, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4041, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(4042, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4043, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4044, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4045, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4046, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4047, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4048, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4049, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4053, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4054, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4055, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4056, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(4057, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4058, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4059, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4060, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4061, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4062, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4063, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4064, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4068, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4069, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4070, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4086, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(4087, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4088, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4089, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4090, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4091, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4092, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4093, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4094, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4098, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4099, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4100, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4116, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(4117, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4118, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4119, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4120, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4121, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4122, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4123, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4124, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4128, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4129, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4130, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4131, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(4132, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4133, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4134, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4135, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4136, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4137, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4138, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4139, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4143, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4144, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4145, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4161, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(4162, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4163, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4164, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4165, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4166, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4167, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4168, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4169, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4173, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4174, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4175, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4191, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(4192, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4193, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4194, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4195, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4196, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4197, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4198, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4199, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4203, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4204, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4205, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4206, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(4207, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4208, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4209, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4210, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4211, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4212, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4213, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4214, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4218, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4219, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4220, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4236, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(4237, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4238, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4239, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4240, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4241, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4242, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4243, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4244, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4248, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4249, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4250, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4254, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(4255, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4256, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4257, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(4258, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4259, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4263, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(4264, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4265, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4266, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(4267, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4268, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4269, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4270, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4271, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4272, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4273, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4274, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4278, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4279, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4280, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4281, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(4282, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4283, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4284, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4285, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4286, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4287, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4288, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4289, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4293, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4294, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4295, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4311, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(4312, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4313, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4314, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4315, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4316, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4317, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4318, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4319, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4323, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4324, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4325, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4329, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(4330, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4331, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4332, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(4333, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4334, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4338, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(4339, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4340, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4341, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(4342, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4343, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4344, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4345, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4346, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4347, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4348, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4349, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4353, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4354, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4355, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4356, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(4357, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4358, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4359, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4360, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4361, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4362, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4363, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4364, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4368, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4369, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4370, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4386, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(4387, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4388, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4389, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4390, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4391, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4392, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4393, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4394, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4398, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4399, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4400, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4404, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(4405, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4406, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4407, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(4408, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4409, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4413, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(4414, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4415, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4416, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(4417, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4418, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4419, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4420, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4421, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4422, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4423, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4424, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4428, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4429, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4430, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4431, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(4432, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4433, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4434, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4435, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4436, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4437, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4438, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4439, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4443, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4444, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4445, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4461, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(4462, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4463, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4464, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4465, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4466, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4467, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4468, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4469, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4473, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(4474, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4475, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4479, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(4480, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4481, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4482, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(4483, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4484, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4488, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(4489, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(4490, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(4491, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(4492, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4493, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4494, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4495, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4496, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4497, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4498, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4499, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4503, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4504, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4505, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4506, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(4507, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4508, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4509, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4510, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4511, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4512, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4513, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4514, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4518, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4519, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4520, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4536, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(4537, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(4538, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(4539, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4540, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4541, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4542, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4543, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4544, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4548, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(4549, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(4550, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(4551, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \ + _(4552, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \ + _(4553, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \ + _(4554, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED) \ + _(4555, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \ + _(4556, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \ + _(4557, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \ + _(4558, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \ + _(4559, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \ + _(4560, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED) \ + _(4561, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \ + _(4562, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \ + _(4563, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \ + _(4564, ZEND_POST_INC_LONG_SPEC_TMPVARCV) \ + _(4565, ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \ + _(4566, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \ + _(4567, ZEND_POST_DEC_LONG_SPEC_TMPVARCV) \ + _(4568, ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \ + _(4569, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ _(4570, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(4572, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(4573, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(4574, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(4571, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(4573, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(4574, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ _(4575, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(4577, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(4579, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(4576, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(4578, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ _(4580, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(4582, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(4583, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(4584, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(4581, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(4583, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(4584, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ _(4585, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(4587, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(4588, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(4589, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(4586, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(4588, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(4589, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ _(4590, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(4592, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(4598, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(4599, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(4591, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(4593, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(4599, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ _(4600, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(4602, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(4605, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(4607, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(4610, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \ - _(4612, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \ - _(4613, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(4614, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(4615, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(4616, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(4616+1, ZEND_NULL) + _(4601, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(4603, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(4606, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(4608, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(4611, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \ + _(4613, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \ + _(4614, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(4615, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(4616, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(4617, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(4617+1, ZEND_NULL) diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index 871f16176faa3..aaf5cb655d256 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 78d2acc46d432..69f4225d36340 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 ad67313bdfb56cc471c13e1c715873363be3d73d Mon Sep 17 00:00:00 2001 From: Levi Morrison Date: Fri, 4 Jan 2019 09:46:56 -0700 Subject: [PATCH 2/5] 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 790dd531a1ae2..da9bca43ea898 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -178,29 +178,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: @@ -221,7 +226,7 @@ zend_string *_resolve_parent_and_self(const zend_function *fe, zend_string *name } return zend_string_copy(name); -} +} /* }}} */ typedef enum { CONTRAVARIANT = -1, From a0892ebccf43e850da3bee6b8e31f682c8ccb7d2 Mon Sep 17 00:00:00 2001 From: Levi Morrison Date: Wed, 9 Jan 2019 11:35:57 -0700 Subject: [PATCH 3/5] 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 | 26 +-- Zend/zend_inheritance.c | 183 ++++++++---------- Zend/zend_vm_def.h | 9 +- Zend/zend_vm_execute.h | 9 +- 8 files changed, 143 insertions(+), 134 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 51abf0fcf9ace..c9cf904421bf2 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -3959,7 +3959,6 @@ void zend_compile_static_call(znode *result, zend_ast *ast, uint32_t type) /* {{ } /* }}} */ - static void _backup_unverified_variance_types(HashTable *unverified_types, HashTable **prev_unverified_types) @@ -8138,8 +8137,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: @@ -8167,11 +8167,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 */ @@ -8180,7 +8179,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); @@ -8193,12 +8193,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 da9bca43ea898..30c8d25e4e3b6 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -209,7 +209,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: @@ -229,43 +229,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); @@ -274,90 +251,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); } @@ -367,31 +332,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; @@ -400,7 +367,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, @@ -409,29 +376,29 @@ static int zend_do_perform_implementation_check(const zend_function *fe, const z if ((fe->common.scope->constructor == fe) && ((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 @@ -456,7 +423,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; } } @@ -466,7 +433,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; } /* }}} */ @@ -703,7 +670,7 @@ static void do_inheritance_check_on_method(zend_function *child, zend_function * zend_error_noreturn(E_COMPILE_ERROR, "Access level to %s::%s() must be %s (as in class %s)%s", 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); @@ -1442,7 +1409,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))); @@ -1450,7 +1417,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))); @@ -1467,14 +1434,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))); @@ -2139,7 +2106,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"; @@ -2163,10 +2134,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)) { @@ -2196,7 +2176,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 4bdb863586fcc..07f724ce896b5 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -6948,12 +6948,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 83eb38c4c1130..173e4fc5ae78a 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -9909,12 +9909,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 b781f9ffdd94da65aa86203bb3ee71d22811918a Mon Sep 17 00:00:00 2001 From: Levi Morrison Date: Thu, 10 Jan 2019 13:33:25 -0700 Subject: [PATCH 4/5] 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 c9cf904421bf2..7e8ebccbfbbf2 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -5220,12 +5220,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); + } } } /* }}} */ @@ -6327,7 +6387,7 @@ void 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"); } } @@ -8129,36 +8189,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 30c8d25e4e3b6..b48e9a30df0fd 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -361,6 +361,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 @@ -416,24 +417,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; } /* }}} */ @@ -2214,7 +2236,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 bf4e912c6da1c3d436e5e57897ac52e265cdd326 Mon Sep 17 00:00:00 2001 From: Levi Morrison Date: Fri, 11 Jan 2019 09:18:07 -0700 Subject: [PATCH 5/5] 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 73bccc524860f..b8b62dcdf6da7 100644 --- a/ext/opcache/tests/opt/prop_types.phpt +++ b/ext/opcache/tests/opt/prop_types.phpt @@ -38,12 +38,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)