diff --git a/Zend/tests/bug75573.phpt b/Zend/tests/bug75573.phpt index 476ff6e6cfab9..f5e87f82838a2 100644 --- a/Zend/tests/bug75573.phpt +++ b/Zend/tests/bug75573.phpt @@ -6,10 +6,6 @@ Bug #75573 (Segmentation fault in 7.1.12 and 7.0.26) class A { var $_stdObject; - function initialize($properties = FALSE) { - $this->_stdObject = $properties ? (object) $properties : new stdClass(); - parent::initialize(); - } function &__get($property) { if (isset($this->_stdObject->{$property})) { @@ -31,10 +27,6 @@ class A class B extends A { - function initialize($properties = array()) - { - parent::initialize($properties); - } function &__get($property) { if (isset($this->settings) && isset($this->settings[$property])) { 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/class_name_as_scalar.phpt b/Zend/tests/class_name_as_scalar.phpt index 72a460abaae0f..a01ac45d81f39 100644 --- a/Zend/tests/class_name_as_scalar.phpt +++ b/Zend/tests/class_name_as_scalar.phpt @@ -8,8 +8,11 @@ namespace Foo\Bar { // compile time constants const A = self::class; const B = Two::class; + } class Two extends One { + const A = parent::class; + public static function run() { var_dump(self::class); // self compile time lookup var_dump(static::class); // runtime lookup @@ -18,6 +21,8 @@ namespace Foo\Bar { } } class Three extends Two { + const B = parent::class; + // compile time static lookups public static function checkCompileTime( $one = self::class, diff --git a/Zend/tests/class_name_as_scalar_error_002.phpt b/Zend/tests/class_name_as_scalar_error_002.phpt index 59b7a2edc9acc..11268fbf017ba 100644 --- a/Zend/tests/class_name_as_scalar_error_002.phpt +++ b/Zend/tests/class_name_as_scalar_error_002.phpt @@ -10,4 +10,6 @@ namespace Foo\Bar { } ?> --EXPECTF-- -Fatal error: parent::class cannot be used for compile-time class name resolution in %s on line %d +Deprecated: Cannot use "parent" without a parent class in %s on line %d + +Fatal error: Cannot use "parent" without a parent class in %s on line %d diff --git a/Zend/tests/class_name_as_scalar_error_004.phpt b/Zend/tests/class_name_as_scalar_error_004.phpt index c00037fca3e15..166e29466bd8a 100644 --- a/Zend/tests/class_name_as_scalar_error_004.phpt +++ b/Zend/tests/class_name_as_scalar_error_004.phpt @@ -10,4 +10,6 @@ namespace Foo\Bar { } ?> --EXPECTF-- -Fatal error: parent::class cannot be used for compile-time class name resolution in %s on line %d +Deprecated: Cannot use "parent" without a parent class in %s on line %d + +Fatal error: Cannot use "parent" without a parent class in %s on line %d diff --git a/Zend/tests/compile_time_parent_error_01.phpt b/Zend/tests/compile_time_parent_error_01.phpt new file mode 100644 index 0000000000000..41929c3fc1b9e --- /dev/null +++ b/Zend/tests/compile_time_parent_error_01.phpt @@ -0,0 +1,11 @@ +--TEST-- +Using "parent" in class without parent results in compile-time error +--FILE-- + +--EXPECTF-- +Deprecated: Cannot use "parent" without a parent class in %s on line %d diff --git a/Zend/tests/compile_time_parent_error_02.phpt b/Zend/tests/compile_time_parent_error_02.phpt new file mode 100644 index 0000000000000..47d8183706007 --- /dev/null +++ b/Zend/tests/compile_time_parent_error_02.phpt @@ -0,0 +1,11 @@ +--TEST-- +Using "parent" in class without parent results in compile-time error +--FILE-- + +--EXPECTF-- +Deprecated: Cannot use "parent" without a parent class in %s on line %d diff --git a/Zend/tests/compile_time_parent_error_03.phpt b/Zend/tests/compile_time_parent_error_03.phpt new file mode 100644 index 0000000000000..4c92e5edce2f9 --- /dev/null +++ b/Zend/tests/compile_time_parent_error_03.phpt @@ -0,0 +1,13 @@ +--TEST-- +Using "parent" in class without parent results in compile-time error +--FILE-- + +--EXPECTF-- +Deprecated: Cannot use "parent" without a parent class in %s on line %d diff --git a/Zend/tests/compile_time_parent_error_04.phpt b/Zend/tests/compile_time_parent_error_04.phpt new file mode 100644 index 0000000000000..a9703f0b4193c --- /dev/null +++ b/Zend/tests/compile_time_parent_error_04.phpt @@ -0,0 +1,13 @@ +--TEST-- +Using "parent" in class without parent results in compile-time error +--FILE-- + +--EXPECTF-- +Deprecated: Cannot use "parent" without a parent class in %s on line %d diff --git a/Zend/tests/compile_time_parent_error_05.phpt b/Zend/tests/compile_time_parent_error_05.phpt new file mode 100644 index 0000000000000..e002197fa4b7c --- /dev/null +++ b/Zend/tests/compile_time_parent_error_05.phpt @@ -0,0 +1,17 @@ +--TEST-- +Using "parent" in class without parent results in compile-time error +--FILE-- + +--EXPECTF-- +Deprecated: Cannot use "parent" without a parent class in %s on line %d 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/traits/parent_001.phpt b/Zend/tests/traits/parent_001.phpt new file mode 100644 index 0000000000000..0274f6bd557fe --- /dev/null +++ b/Zend/tests/traits/parent_001.phpt @@ -0,0 +1,26 @@ +--TEST-- +Using parent does not create compile-time warnings +--FILE-- +m(new A()); + +print "OK\n"; + +?> +--EXPECT-- +OK + diff --git a/Zend/zend.c b/Zend/zend.c index 7dbb114d79606..f0c1f06a9755d 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 b6c8176cc4b0b..2e9a3d053ee67 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -1358,10 +1358,17 @@ static uint32_t zend_get_class_fetch_type_ast(zend_ast *name_ast) /* {{{ */ static void zend_ensure_valid_class_fetch_type(uint32_t fetch_type) /* {{{ */ { - if (fetch_type != ZEND_FETCH_CLASS_DEFAULT && !CG(active_class_entry) && zend_is_scope_known()) { - zend_error_noreturn(E_COMPILE_ERROR, "Cannot use \"%s\" when no class scope is active", - fetch_type == ZEND_FETCH_CLASS_SELF ? "self" : - fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static"); + if (fetch_type != ZEND_FETCH_CLASS_DEFAULT && zend_is_scope_known()) { + zend_class_entry *ce = CG(active_class_entry); + if (!ce) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot use \"%s\" when no class scope is active", + fetch_type == ZEND_FETCH_CLASS_SELF ? "self" : + fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static"); + } else if (fetch_type == ZEND_FETCH_CLASS_PARENT && !ce->parent_name) { + zend_error(E_DEPRECATED, + "Cannot use \"parent\" without a parent class"); + } } } /* }}} */ @@ -1384,7 +1391,6 @@ static zend_bool zend_try_compile_const_expr_resolve_class_name(zval *zv, zend_a } fetch_type = zend_get_class_fetch_type(zend_ast_get_str(class_ast)); - zend_ensure_valid_class_fetch_type(fetch_type); switch (fetch_type) { case ZEND_FETCH_CLASS_SELF: @@ -1394,13 +1400,29 @@ static zend_bool zend_try_compile_const_expr_resolve_class_name(zval *zv, zend_a ZVAL_NULL(zv); } return 1; - case ZEND_FETCH_CLASS_STATIC: + case ZEND_FETCH_CLASS_PARENT: + if (zend_is_scope_known()) { + if (CG(active_class_entry)->parent_name) { + ZVAL_STR_COPY(zv, CG(active_class_entry)->parent_name); + return 1; + } + if (constant) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot use \"parent\" without a parent class"); + } else { + zend_error(E_DEPRECATED, + "Cannot use \"parent\" without a parent class"); + } + } + ZVAL_NULL(zv); + return 1; + + case ZEND_FETCH_CLASS_STATIC: + zend_ensure_valid_class_fetch_type(fetch_type); if (constant) { zend_error_noreturn(E_COMPILE_ERROR, - "%s::class cannot be used for compile-time class name resolution", - fetch_type == ZEND_FETCH_CLASS_STATIC ? "static" : "parent" - ); + "static::class cannot be used for compile-time class name resolution"); } else { ZVAL_NULL(zv); } @@ -4092,6 +4114,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) /* {{{ */ @@ -4103,16 +4146,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_ex(&class_node, class_ast, ZEND_FETCH_CLASS_EXCEPTION); } @@ -6370,6 +6426,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))) { @@ -8052,6 +8116,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) /* {{{ */ { @@ -8061,9 +8154,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 460e0056e031c..8d6c2ff4e1385 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 387c1ca4d7810..92abf3bf5b287 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" @@ -173,72 +174,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; @@ -249,11 +378,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; @@ -261,7 +390,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; } @@ -303,7 +432,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++; @@ -313,35 +442,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; } } @@ -349,27 +454,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; } @@ -620,9 +706,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 { @@ -1933,6 +2017,115 @@ 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) +{ + zend_function *proto = child->common.prototype; + if ((proto && (proto->common.fn_flags & ZEND_ACC_ABSTRACT)) + || ((parent->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) + && _check_inherited_return_type(child, child->common.arg_info - 1, parent, parent->common.arg_info - 1) <= 0)) + { + zend_string *method_prototype = zend_get_function_declaration(parent); + zend_string *child_prototype = zend_get_function_declaration(child); + zend_error(E_ERROR, "Declaration of %s must be compatible with %s", ZSTR_VAL(child_prototype), ZSTR_VAL(method_prototype)); + zend_string_efree(child_prototype); + zend_string_efree(method_prototype); + } +} + +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 { + _inheritance_runtime_error_msg(child, parent); + // todo: what to do with errors, not warnings? + continue; + } + } + + if (parent->common.required_num_args < child->common.required_num_args + || parent->common.num_args > child->common.num_args) + { + _inheritance_runtime_error_msg(child, parent); + // todo: what to do with errors, not warnings? + 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 bda628fc29475..44c105dd660fe 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 b82982bd33ed4..f3ca802e3d53c 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -6695,6 +6695,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 73a47fbc4b17b..d90ef94095cf3 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -9141,6 +9141,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 @@ -53489,6 +53505,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, @@ -56007,6 +56024,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); @@ -63045,6 +63066,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, @@ -64695,63 +64717,63 @@ void zend_vm_init(void) 2430, 2431 | SPEC_RULE_OP1, 2436, - 3941, + 3942, 2437, - 3941, - 2438 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA, - 2563 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2588, + 2438, + 2439 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA, + 2564 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 2589, 2590, - 2591 | SPEC_RULE_OP1, - 2596, - 3941, - 3941, + 2591, + 2592 | SPEC_RULE_OP1, 2597, + 3942, + 3942, 2598, 2599, 2600, - 2601 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2626 | SPEC_RULE_OP1, - 2631, + 2601, + 2602 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2627 | SPEC_RULE_OP1, 2632, 2633, 2634, - 2635 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2660 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ, - 2735, - 2736 | SPEC_RULE_OP1, - 2741 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2766, + 2635, + 2636 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2661 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ, + 2736, + 2737 | SPEC_RULE_OP1, + 2742 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 2767, - 2768 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2793 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2818 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2843 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2868 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2893 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2918 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2943 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2968 | SPEC_RULE_OP1, - 2973, + 2768, + 2769 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2794 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2819 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2844 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2869 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2894 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2919 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2944 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2969 | SPEC_RULE_OP1, 2974, 2975, 2976, 2977, - 2978 | SPEC_RULE_OP1, - 2983 | SPEC_RULE_OP1, - 2988 | SPEC_RULE_OP1, - 2993 | SPEC_RULE_OP1, - 2998 | SPEC_RULE_OP1, - 3003, - 3004 | SPEC_RULE_OP1, - 3009, - 3010 | SPEC_RULE_OP1, - 3015, - 3016 | SPEC_RULE_ISSET, - 3018 | SPEC_RULE_OP2, - 3023 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3941 + 2978, + 2979 | SPEC_RULE_OP1, + 2984 | SPEC_RULE_OP1, + 2989 | SPEC_RULE_OP1, + 2994 | SPEC_RULE_OP1, + 2999 | SPEC_RULE_OP1, + 3004, + 3005 | SPEC_RULE_OP1, + 3010, + 3011 | SPEC_RULE_OP1, + 3016, + 3017 | SPEC_RULE_ISSET, + 3019 | SPEC_RULE_OP2, + 3024 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 3942 }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -64954,7 +64976,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 = 3049 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3050 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -64962,7 +64984,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 = 3074 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3075 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -64970,7 +64992,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 = 3099 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3100 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -64981,17 +65003,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 = 3124 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3125 | 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 = 3149 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3150 | 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 = 3174 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3175 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -65002,17 +65024,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 = 3199 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3200 | 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 = 3224 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3225 | 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 = 3249 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3250 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -65023,12 +65045,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 = 3274 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3275 | 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 = 3349 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3350 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -65039,12 +65061,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 = 3424 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3425 | 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 = 3499 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3500 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -65052,12 +65074,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 = 3574 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3575 | 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 = 3649 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3650 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -65065,75 +65087,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 = 3724 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3725 | 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 = 3799 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3800 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_DOUBLE) { - spec = 3892 | SPEC_RULE_OP1; + spec = 3893 | 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 = 3897 | SPEC_RULE_OP1; + spec = 3898 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3874 | SPEC_RULE_RETVAL; + spec = 3875 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3876 | SPEC_RULE_RETVAL; + spec = 3877 | SPEC_RULE_RETVAL; } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) { - spec = 3878 | SPEC_RULE_RETVAL; + spec = 3879 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3880 | SPEC_RULE_RETVAL; + spec = 3881 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3882 | SPEC_RULE_RETVAL; + spec = 3883 | SPEC_RULE_RETVAL; } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) { - spec = 3884 | SPEC_RULE_RETVAL; + spec = 3885 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3886; - } else if (op1_info == MAY_BE_LONG) { spec = 3887; - } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) { + } else if (op1_info == MAY_BE_LONG) { spec = 3888; + } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) { + spec = 3889; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3889; - } else if (op1_info == MAY_BE_LONG) { spec = 3890; - } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) { + } else if (op1_info == MAY_BE_LONG) { spec = 3891; + } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) { + spec = 3892; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 3048; + spec = 3049; } break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3937; + spec = 3938; } break; case ZEND_SEND_VAR_EX: if (op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3932 | SPEC_RULE_OP1; + spec = 3933 | 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 = 3939 | SPEC_RULE_RETVAL; + spec = 3940 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -65141,17 +65163,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 = 3902 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3903 | 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 = 3938; + spec = 3939; } break; case ZEND_SEND_VAR: if ((op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3927 | SPEC_RULE_OP1; + spec = 3928 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 65342d343bc89..e421c558ee6cd 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -1247,825 +1247,826 @@ _(2435, ZEND_YIELD_FROM_SPEC_CV) \ _(2436, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ _(2437, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_CONST_CONST) \ - _(2488, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST) \ - _(2489, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP) \ - _(2490, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR) \ - _(2492, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV) \ - _(2493, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST) \ - _(2494, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP) \ - _(2495, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ - _(2497, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV) \ - _(2498, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST) \ - _(2499, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP) \ - _(2500, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ - _(2502, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV) \ - _(2503, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST) \ - _(2504, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP) \ - _(2505, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR) \ - _(2507, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV) \ - _(2508, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST) \ - _(2509, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP) \ - _(2510, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR) \ - _(2512, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV) \ - _(2538, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST) \ - _(2539, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP) \ - _(2540, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR) \ - _(2542, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV) \ - _(2543, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST) \ - _(2544, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP) \ - _(2545, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR) \ - _(2547, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV) \ - _(2548, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST) \ - _(2549, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP) \ - _(2550, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR) \ - _(2552, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV) \ - _(2553, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST) \ - _(2554, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP) \ - _(2555, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR) \ - _(2557, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV) \ - _(2558, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST) \ - _(2559, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP) \ - _(2560, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR) \ - _(2562, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV) \ - _(2563, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ - _(2564, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ + _(2438, ZEND_VERIFY_VARIANCE_SPEC_CONST_UNUSED) \ + _(2489, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST) \ + _(2490, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP) \ + _(2491, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR) \ + _(2493, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV) \ + _(2494, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST) \ + _(2495, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP) \ + _(2496, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ + _(2498, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV) \ + _(2499, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST) \ + _(2500, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP) \ + _(2501, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ + _(2503, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV) \ + _(2504, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST) \ + _(2505, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP) \ + _(2506, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR) \ + _(2508, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV) \ + _(2509, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST) \ + _(2510, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP) \ + _(2511, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR) \ + _(2513, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV) \ + _(2539, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST) \ + _(2540, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP) \ + _(2541, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR) \ + _(2543, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV) \ + _(2544, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST) \ + _(2545, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP) \ + _(2546, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR) \ + _(2548, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV) \ + _(2549, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST) \ + _(2550, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP) \ + _(2551, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR) \ + _(2553, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV) \ + _(2554, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST) \ + _(2555, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP) \ + _(2556, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR) \ + _(2558, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV) \ + _(2559, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST) \ + _(2560, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP) \ + _(2561, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR) \ + _(2563, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV) \ + _(2564, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ _(2565, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ - _(2567, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ - _(2568, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ - _(2569, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2566, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ + _(2568, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ + _(2569, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ _(2570, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2572, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ - _(2573, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ - _(2574, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2571, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2573, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ + _(2574, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ _(2575, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2577, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ - _(2578, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ - _(2579, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2576, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ + _(2578, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ + _(2579, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ _(2580, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2582, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ - _(2583, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ - _(2584, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ + _(2581, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ + _(2583, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ + _(2584, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ _(2585, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ - _(2587, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ - _(2588, ZEND_HANDLE_EXCEPTION_SPEC) \ - _(2589, ZEND_USER_OPCODE_SPEC) \ - _(2590, ZEND_ASSERT_CHECK_SPEC) \ - _(2591, ZEND_JMP_SET_SPEC_CONST) \ - _(2592, ZEND_JMP_SET_SPEC_TMP) \ - _(2593, ZEND_JMP_SET_SPEC_VAR) \ - _(2595, ZEND_JMP_SET_SPEC_CV) \ - _(2596, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) \ - _(2597, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ - _(2598, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ - _(2599, ZEND_CALL_TRAMPOLINE_SPEC) \ - _(2600, ZEND_DISCARD_EXCEPTION_SPEC) \ - _(2601, ZEND_YIELD_SPEC_CONST_CONST) \ - _(2602, ZEND_YIELD_SPEC_CONST_TMP) \ - _(2603, ZEND_YIELD_SPEC_CONST_VAR) \ - _(2604, ZEND_YIELD_SPEC_CONST_UNUSED) \ - _(2605, ZEND_YIELD_SPEC_CONST_CV) \ - _(2606, ZEND_YIELD_SPEC_TMP_CONST) \ - _(2607, ZEND_YIELD_SPEC_TMP_TMP) \ - _(2608, ZEND_YIELD_SPEC_TMP_VAR) \ - _(2609, ZEND_YIELD_SPEC_TMP_UNUSED) \ - _(2610, ZEND_YIELD_SPEC_TMP_CV) \ - _(2611, ZEND_YIELD_SPEC_VAR_CONST) \ - _(2612, ZEND_YIELD_SPEC_VAR_TMP) \ - _(2613, ZEND_YIELD_SPEC_VAR_VAR) \ - _(2614, ZEND_YIELD_SPEC_VAR_UNUSED) \ - _(2615, ZEND_YIELD_SPEC_VAR_CV) \ - _(2616, ZEND_YIELD_SPEC_UNUSED_CONST) \ - _(2617, ZEND_YIELD_SPEC_UNUSED_TMP) \ - _(2618, ZEND_YIELD_SPEC_UNUSED_VAR) \ - _(2619, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ - _(2620, ZEND_YIELD_SPEC_UNUSED_CV) \ - _(2621, ZEND_YIELD_SPEC_CV_CONST) \ - _(2622, ZEND_YIELD_SPEC_CV_TMP) \ - _(2623, ZEND_YIELD_SPEC_CV_VAR) \ - _(2624, ZEND_YIELD_SPEC_CV_UNUSED) \ - _(2625, ZEND_YIELD_SPEC_CV_CV) \ - _(2626, ZEND_GENERATOR_RETURN_SPEC_CONST) \ - _(2627, ZEND_GENERATOR_RETURN_SPEC_TMP) \ - _(2628, ZEND_GENERATOR_RETURN_SPEC_VAR) \ - _(2630, ZEND_GENERATOR_RETURN_SPEC_CV) \ - _(2631, ZEND_FAST_CALL_SPEC) \ - _(2632, ZEND_FAST_RET_SPEC) \ - _(2633, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ - _(2634, ZEND_SEND_UNPACK_SPEC) \ - _(2635, ZEND_POW_SPEC_CONST_CONST) \ - _(2636, ZEND_POW_SPEC_CONST_TMPVAR) \ + _(2586, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ + _(2588, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ + _(2589, ZEND_HANDLE_EXCEPTION_SPEC) \ + _(2590, ZEND_USER_OPCODE_SPEC) \ + _(2591, ZEND_ASSERT_CHECK_SPEC) \ + _(2592, ZEND_JMP_SET_SPEC_CONST) \ + _(2593, ZEND_JMP_SET_SPEC_TMP) \ + _(2594, ZEND_JMP_SET_SPEC_VAR) \ + _(2596, ZEND_JMP_SET_SPEC_CV) \ + _(2597, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) \ + _(2598, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ + _(2599, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ + _(2600, ZEND_CALL_TRAMPOLINE_SPEC) \ + _(2601, ZEND_DISCARD_EXCEPTION_SPEC) \ + _(2602, ZEND_YIELD_SPEC_CONST_CONST) \ + _(2603, ZEND_YIELD_SPEC_CONST_TMP) \ + _(2604, ZEND_YIELD_SPEC_CONST_VAR) \ + _(2605, ZEND_YIELD_SPEC_CONST_UNUSED) \ + _(2606, ZEND_YIELD_SPEC_CONST_CV) \ + _(2607, ZEND_YIELD_SPEC_TMP_CONST) \ + _(2608, ZEND_YIELD_SPEC_TMP_TMP) \ + _(2609, ZEND_YIELD_SPEC_TMP_VAR) \ + _(2610, ZEND_YIELD_SPEC_TMP_UNUSED) \ + _(2611, ZEND_YIELD_SPEC_TMP_CV) \ + _(2612, ZEND_YIELD_SPEC_VAR_CONST) \ + _(2613, ZEND_YIELD_SPEC_VAR_TMP) \ + _(2614, ZEND_YIELD_SPEC_VAR_VAR) \ + _(2615, ZEND_YIELD_SPEC_VAR_UNUSED) \ + _(2616, ZEND_YIELD_SPEC_VAR_CV) \ + _(2617, ZEND_YIELD_SPEC_UNUSED_CONST) \ + _(2618, ZEND_YIELD_SPEC_UNUSED_TMP) \ + _(2619, ZEND_YIELD_SPEC_UNUSED_VAR) \ + _(2620, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ + _(2621, ZEND_YIELD_SPEC_UNUSED_CV) \ + _(2622, ZEND_YIELD_SPEC_CV_CONST) \ + _(2623, ZEND_YIELD_SPEC_CV_TMP) \ + _(2624, ZEND_YIELD_SPEC_CV_VAR) \ + _(2625, ZEND_YIELD_SPEC_CV_UNUSED) \ + _(2626, ZEND_YIELD_SPEC_CV_CV) \ + _(2627, ZEND_GENERATOR_RETURN_SPEC_CONST) \ + _(2628, ZEND_GENERATOR_RETURN_SPEC_TMP) \ + _(2629, ZEND_GENERATOR_RETURN_SPEC_VAR) \ + _(2631, ZEND_GENERATOR_RETURN_SPEC_CV) \ + _(2632, ZEND_FAST_CALL_SPEC) \ + _(2633, ZEND_FAST_RET_SPEC) \ + _(2634, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ + _(2635, ZEND_SEND_UNPACK_SPEC) \ + _(2636, ZEND_POW_SPEC_CONST_CONST) \ _(2637, ZEND_POW_SPEC_CONST_TMPVAR) \ - _(2639, ZEND_POW_SPEC_CONST_CV) \ - _(2640, ZEND_POW_SPEC_TMPVAR_CONST) \ - _(2641, ZEND_POW_SPEC_TMPVAR_TMPVAR) \ + _(2638, ZEND_POW_SPEC_CONST_TMPVAR) \ + _(2640, ZEND_POW_SPEC_CONST_CV) \ + _(2641, ZEND_POW_SPEC_TMPVAR_CONST) \ _(2642, ZEND_POW_SPEC_TMPVAR_TMPVAR) \ - _(2644, ZEND_POW_SPEC_TMPVAR_CV) \ - _(2645, ZEND_POW_SPEC_TMPVAR_CONST) \ - _(2646, ZEND_POW_SPEC_TMPVAR_TMPVAR) \ + _(2643, ZEND_POW_SPEC_TMPVAR_TMPVAR) \ + _(2645, ZEND_POW_SPEC_TMPVAR_CV) \ + _(2646, ZEND_POW_SPEC_TMPVAR_CONST) \ _(2647, ZEND_POW_SPEC_TMPVAR_TMPVAR) \ - _(2649, ZEND_POW_SPEC_TMPVAR_CV) \ - _(2655, ZEND_POW_SPEC_CV_CONST) \ - _(2656, ZEND_POW_SPEC_CV_TMPVAR) \ + _(2648, ZEND_POW_SPEC_TMPVAR_TMPVAR) \ + _(2650, ZEND_POW_SPEC_TMPVAR_CV) \ + _(2656, ZEND_POW_SPEC_CV_CONST) \ _(2657, ZEND_POW_SPEC_CV_TMPVAR) \ - _(2659, ZEND_POW_SPEC_CV_CV) \ - _(2690, ZEND_ASSIGN_POW_SPEC_VAR_CONST) \ - _(2691, ZEND_ASSIGN_POW_SPEC_VAR_CONST_DIM) \ - _(2692, ZEND_ASSIGN_POW_SPEC_VAR_CONST_OBJ) \ - _(2693, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR) \ - _(2694, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM) \ - _(2695, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ) \ - _(2696, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR) \ - _(2697, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM) \ - _(2698, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ) \ - _(2700, ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_DIM) \ - _(2702, ZEND_ASSIGN_POW_SPEC_VAR_CV) \ - _(2703, ZEND_ASSIGN_POW_SPEC_VAR_CV_DIM) \ - _(2704, ZEND_ASSIGN_POW_SPEC_VAR_CV_OBJ) \ - _(2707, ZEND_ASSIGN_POW_SPEC_UNUSED_CONST_OBJ) \ - _(2710, ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ) \ - _(2713, ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ) \ - _(2719, ZEND_ASSIGN_POW_SPEC_UNUSED_CV_OBJ) \ - _(2720, ZEND_ASSIGN_POW_SPEC_CV_CONST) \ - _(2721, ZEND_ASSIGN_POW_SPEC_CV_CONST_DIM) \ - _(2722, ZEND_ASSIGN_POW_SPEC_CV_CONST_OBJ) \ - _(2723, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR) \ - _(2724, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM) \ - _(2725, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ) \ - _(2726, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR) \ - _(2727, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM) \ - _(2728, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ) \ - _(2730, ZEND_ASSIGN_POW_SPEC_CV_UNUSED_DIM) \ - _(2732, ZEND_ASSIGN_POW_SPEC_CV_CV) \ - _(2733, ZEND_ASSIGN_POW_SPEC_CV_CV_DIM) \ - _(2734, ZEND_ASSIGN_POW_SPEC_CV_CV_OBJ) \ - _(2735, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ - _(2736, ZEND_COALESCE_SPEC_CONST) \ - _(2737, ZEND_COALESCE_SPEC_TMPVAR) \ + _(2658, ZEND_POW_SPEC_CV_TMPVAR) \ + _(2660, ZEND_POW_SPEC_CV_CV) \ + _(2691, ZEND_ASSIGN_POW_SPEC_VAR_CONST) \ + _(2692, ZEND_ASSIGN_POW_SPEC_VAR_CONST_DIM) \ + _(2693, ZEND_ASSIGN_POW_SPEC_VAR_CONST_OBJ) \ + _(2694, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR) \ + _(2695, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM) \ + _(2696, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ) \ + _(2697, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR) \ + _(2698, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM) \ + _(2699, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ) \ + _(2701, ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_DIM) \ + _(2703, ZEND_ASSIGN_POW_SPEC_VAR_CV) \ + _(2704, ZEND_ASSIGN_POW_SPEC_VAR_CV_DIM) \ + _(2705, ZEND_ASSIGN_POW_SPEC_VAR_CV_OBJ) \ + _(2708, ZEND_ASSIGN_POW_SPEC_UNUSED_CONST_OBJ) \ + _(2711, ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ) \ + _(2714, ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ) \ + _(2720, ZEND_ASSIGN_POW_SPEC_UNUSED_CV_OBJ) \ + _(2721, ZEND_ASSIGN_POW_SPEC_CV_CONST) \ + _(2722, ZEND_ASSIGN_POW_SPEC_CV_CONST_DIM) \ + _(2723, ZEND_ASSIGN_POW_SPEC_CV_CONST_OBJ) \ + _(2724, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR) \ + _(2725, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM) \ + _(2726, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ) \ + _(2727, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR) \ + _(2728, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM) \ + _(2729, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ) \ + _(2731, ZEND_ASSIGN_POW_SPEC_CV_UNUSED_DIM) \ + _(2733, ZEND_ASSIGN_POW_SPEC_CV_CV) \ + _(2734, ZEND_ASSIGN_POW_SPEC_CV_CV_DIM) \ + _(2735, ZEND_ASSIGN_POW_SPEC_CV_CV_OBJ) \ + _(2736, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ + _(2737, ZEND_COALESCE_SPEC_CONST) \ _(2738, ZEND_COALESCE_SPEC_TMPVAR) \ - _(2740, ZEND_COALESCE_SPEC_CV) \ - _(2741, ZEND_SPACESHIP_SPEC_CONST_CONST) \ - _(2742, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ + _(2739, ZEND_COALESCE_SPEC_TMPVAR) \ + _(2741, ZEND_COALESCE_SPEC_CV) \ + _(2742, ZEND_SPACESHIP_SPEC_CONST_CONST) \ _(2743, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ - _(2745, ZEND_SPACESHIP_SPEC_CONST_CV) \ - _(2746, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ - _(2747, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2744, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ + _(2746, ZEND_SPACESHIP_SPEC_CONST_CV) \ + _(2747, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ _(2748, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2750, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(2751, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ - _(2752, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2749, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2751, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(2752, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ _(2753, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2755, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(2761, ZEND_SPACESHIP_SPEC_CV_CONST) \ - _(2762, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ + _(2754, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ + _(2756, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(2762, ZEND_SPACESHIP_SPEC_CV_CONST) \ _(2763, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ - _(2765, ZEND_SPACESHIP_SPEC_CV_CV) \ - _(2766, ZEND_DECLARE_ANON_CLASS_SPEC) \ - _(2767, ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_CONST_CONST) \ - _(2768, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_CONST) \ - _(2770, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_VAR) \ - _(2771, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_UNUSED) \ - _(2773, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST) \ - _(2775, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR) \ - _(2776, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_UNUSED) \ - _(2778, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST) \ - _(2780, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR) \ - _(2781, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_UNUSED) \ - _(2788, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_CONST) \ - _(2790, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_VAR) \ - _(2791, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_UNUSED) \ - _(2793, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_CONST) \ - _(2795, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_VAR) \ - _(2796, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_UNUSED) \ - _(2798, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_CONST) \ - _(2800, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_VAR) \ - _(2801, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_UNUSED) \ - _(2803, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_CONST) \ - _(2805, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_VAR) \ - _(2806, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_UNUSED) \ - _(2813, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_CONST) \ - _(2815, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_VAR) \ - _(2816, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_UNUSED) \ - _(2818, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_CONST) \ - _(2820, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_VAR) \ - _(2821, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_UNUSED) \ - _(2823, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_CONST) \ - _(2825, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_VAR) \ - _(2826, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_UNUSED) \ - _(2828, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_CONST) \ - _(2830, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_VAR) \ - _(2831, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_UNUSED) \ - _(2838, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_CONST) \ - _(2840, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_VAR) \ - _(2841, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_UNUSED) \ - _(2843, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_CONST) \ - _(2845, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_VAR) \ - _(2846, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_UNUSED) \ - _(2848, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_CONST) \ - _(2850, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_VAR) \ - _(2851, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_UNUSED) \ - _(2853, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_CONST) \ - _(2855, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_VAR) \ - _(2856, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_UNUSED) \ - _(2863, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_CONST) \ - _(2865, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_VAR) \ - _(2866, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_UNUSED) \ - _(2868, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_CONST) \ - _(2870, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_VAR) \ - _(2871, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_UNUSED) \ - _(2873, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_CONST) \ - _(2875, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_VAR) \ - _(2876, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ - _(2878, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_CONST) \ - _(2880, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_VAR) \ - _(2881, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ - _(2888, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_CONST) \ - _(2890, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_VAR) \ - _(2891, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_UNUSED) \ - _(2893, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_CONST) \ - _(2895, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_VAR) \ - _(2896, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_UNUSED) \ - _(2898, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_CONST) \ - _(2900, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_VAR) \ - _(2901, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_UNUSED) \ - _(2903, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_CONST) \ - _(2905, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_VAR) \ - _(2906, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_UNUSED) \ - _(2913, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_CONST) \ - _(2915, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_VAR) \ - _(2916, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_UNUSED) \ - _(2918, ZEND_UNSET_STATIC_PROP_SPEC_CONST_CONST) \ - _(2920, ZEND_UNSET_STATIC_PROP_SPEC_CONST_VAR) \ - _(2921, ZEND_UNSET_STATIC_PROP_SPEC_CONST_UNUSED) \ - _(2923, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_CONST) \ - _(2925, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR) \ - _(2926, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ - _(2928, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_CONST) \ - _(2930, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR) \ - _(2931, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ - _(2938, ZEND_UNSET_STATIC_PROP_SPEC_CV_CONST) \ - _(2940, ZEND_UNSET_STATIC_PROP_SPEC_CV_VAR) \ - _(2941, ZEND_UNSET_STATIC_PROP_SPEC_CV_UNUSED) \ - _(2943, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_CONST) \ - _(2945, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_VAR) \ - _(2946, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_UNUSED) \ - _(2948, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_CONST) \ - _(2950, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_VAR) \ - _(2951, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ - _(2953, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_CONST) \ - _(2955, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_VAR) \ - _(2956, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ - _(2963, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_CONST) \ - _(2965, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_VAR) \ - _(2966, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_UNUSED) \ - _(2968, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ - _(2970, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ - _(2971, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ - _(2973, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ - _(2974, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \ - _(2975, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ - _(2976, ZEND_SEND_FUNC_ARG_SPEC_VAR) \ - _(2977, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ - _(2978, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ - _(2979, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2764, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ + _(2766, ZEND_SPACESHIP_SPEC_CV_CV) \ + _(2767, ZEND_DECLARE_ANON_CLASS_SPEC) \ + _(2768, ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_CONST_CONST) \ + _(2769, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_CONST) \ + _(2771, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_VAR) \ + _(2772, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_UNUSED) \ + _(2774, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST) \ + _(2776, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR) \ + _(2777, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_UNUSED) \ + _(2779, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST) \ + _(2781, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR) \ + _(2782, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_UNUSED) \ + _(2789, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_CONST) \ + _(2791, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_VAR) \ + _(2792, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_UNUSED) \ + _(2794, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_CONST) \ + _(2796, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_VAR) \ + _(2797, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_UNUSED) \ + _(2799, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_CONST) \ + _(2801, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_VAR) \ + _(2802, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_UNUSED) \ + _(2804, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_CONST) \ + _(2806, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_VAR) \ + _(2807, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_UNUSED) \ + _(2814, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_CONST) \ + _(2816, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_VAR) \ + _(2817, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_UNUSED) \ + _(2819, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_CONST) \ + _(2821, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_VAR) \ + _(2822, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_UNUSED) \ + _(2824, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_CONST) \ + _(2826, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_VAR) \ + _(2827, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_UNUSED) \ + _(2829, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_CONST) \ + _(2831, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_VAR) \ + _(2832, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_UNUSED) \ + _(2839, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_CONST) \ + _(2841, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_VAR) \ + _(2842, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_UNUSED) \ + _(2844, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_CONST) \ + _(2846, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_VAR) \ + _(2847, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_UNUSED) \ + _(2849, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_CONST) \ + _(2851, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_VAR) \ + _(2852, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_UNUSED) \ + _(2854, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_CONST) \ + _(2856, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_VAR) \ + _(2857, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_UNUSED) \ + _(2864, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_CONST) \ + _(2866, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_VAR) \ + _(2867, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_UNUSED) \ + _(2869, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_CONST) \ + _(2871, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_VAR) \ + _(2872, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_UNUSED) \ + _(2874, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_CONST) \ + _(2876, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_VAR) \ + _(2877, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ + _(2879, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_CONST) \ + _(2881, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_VAR) \ + _(2882, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ + _(2889, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_CONST) \ + _(2891, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_VAR) \ + _(2892, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_UNUSED) \ + _(2894, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_CONST) \ + _(2896, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_VAR) \ + _(2897, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_UNUSED) \ + _(2899, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_CONST) \ + _(2901, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_VAR) \ + _(2902, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_UNUSED) \ + _(2904, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_CONST) \ + _(2906, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_VAR) \ + _(2907, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_UNUSED) \ + _(2914, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_CONST) \ + _(2916, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_VAR) \ + _(2917, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_UNUSED) \ + _(2919, ZEND_UNSET_STATIC_PROP_SPEC_CONST_CONST) \ + _(2921, ZEND_UNSET_STATIC_PROP_SPEC_CONST_VAR) \ + _(2922, ZEND_UNSET_STATIC_PROP_SPEC_CONST_UNUSED) \ + _(2924, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_CONST) \ + _(2926, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR) \ + _(2927, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ + _(2929, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_CONST) \ + _(2931, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR) \ + _(2932, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ + _(2939, ZEND_UNSET_STATIC_PROP_SPEC_CV_CONST) \ + _(2941, ZEND_UNSET_STATIC_PROP_SPEC_CV_VAR) \ + _(2942, ZEND_UNSET_STATIC_PROP_SPEC_CV_UNUSED) \ + _(2944, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_CONST) \ + _(2946, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_VAR) \ + _(2947, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_UNUSED) \ + _(2949, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_CONST) \ + _(2951, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_VAR) \ + _(2952, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ + _(2954, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_CONST) \ + _(2956, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_VAR) \ + _(2957, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_UNUSED) \ + _(2964, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_CONST) \ + _(2966, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_VAR) \ + _(2967, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_UNUSED) \ + _(2969, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ + _(2971, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ + _(2972, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ + _(2974, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ + _(2975, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \ + _(2976, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ + _(2977, ZEND_SEND_FUNC_ARG_SPEC_VAR) \ + _(2978, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ + _(2979, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ _(2980, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2982, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2983, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ - _(2984, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2981, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2983, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2984, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ _(2985, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2987, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2988, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ - _(2989, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ - _(2990, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ - _(2992, ZEND_IN_ARRAY_SPEC_CV_CONST) \ - _(2993, ZEND_COUNT_SPEC_CONST_UNUSED) \ - _(2994, ZEND_COUNT_SPEC_TMP_UNUSED) \ - _(2995, ZEND_COUNT_SPEC_VAR_UNUSED) \ - _(2997, ZEND_COUNT_SPEC_CV_UNUSED) \ - _(2998, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ - _(2999, ZEND_GET_CLASS_SPEC_TMP_UNUSED) \ - _(3000, ZEND_GET_CLASS_SPEC_VAR_UNUSED) \ - _(3001, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ - _(3002, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ - _(3003, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ - _(3004, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ - _(3005, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ - _(3006, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ - _(3008, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ - _(3009, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ - _(3010, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ - _(3013, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ - _(3015, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ - _(3016, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ - _(3017, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ - _(3018, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ - _(3019, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ + _(2986, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2988, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2989, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ + _(2990, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ + _(2991, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ + _(2993, ZEND_IN_ARRAY_SPEC_CV_CONST) \ + _(2994, ZEND_COUNT_SPEC_CONST_UNUSED) \ + _(2995, ZEND_COUNT_SPEC_TMP_UNUSED) \ + _(2996, ZEND_COUNT_SPEC_VAR_UNUSED) \ + _(2998, ZEND_COUNT_SPEC_CV_UNUSED) \ + _(2999, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ + _(3000, ZEND_GET_CLASS_SPEC_TMP_UNUSED) \ + _(3001, ZEND_GET_CLASS_SPEC_VAR_UNUSED) \ + _(3002, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ + _(3003, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ + _(3004, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ + _(3005, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ + _(3006, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ + _(3007, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ + _(3009, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ + _(3010, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ + _(3011, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ + _(3014, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ + _(3016, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ + _(3017, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ + _(3018, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ + _(3019, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ _(3020, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ - _(3022, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ - _(3023, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ - _(3024, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ + _(3021, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ + _(3023, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ + _(3024, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ _(3025, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ - _(3027, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ - _(3028, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ - _(3029, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(3026, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ + _(3028, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ + _(3029, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ _(3030, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(3032, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(3033, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ - _(3034, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(3031, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(3033, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(3034, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ _(3035, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(3037, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(3043, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ - _(3044, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ + _(3036, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ + _(3038, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(3044, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ _(3045, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ - _(3047, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ - _(3048, ZEND_JMP_FORWARD_SPEC) \ - _(3054, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3055, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3046, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ + _(3048, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ + _(3049, ZEND_JMP_FORWARD_SPEC) \ + _(3055, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3056, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3058, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3059, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3060, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3057, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3059, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3060, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3061, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3063, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3069, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3070, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3062, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3064, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3070, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3071, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3073, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3079, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(3080, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3072, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3074, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3080, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(3081, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3083, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3084, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(3085, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3082, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3084, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3085, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(3086, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3088, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3094, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(3095, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3087, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3089, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3095, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(3096, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3098, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3104, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3105, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3097, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3099, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3105, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3106, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3108, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3109, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3110, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3107, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3109, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3110, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3111, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3113, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3119, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3120, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3112, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3114, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3120, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3121, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3123, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3125, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(3122, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3124, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3126, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(3128, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(3129, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3130, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3127, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(3129, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(3130, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3131, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3133, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3134, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3135, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3132, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3134, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3135, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3136, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3138, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3144, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3145, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3137, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3139, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3145, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3146, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3148, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3150, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(3147, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3149, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(3151, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(3153, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(3154, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(3155, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3152, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(3154, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(3155, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(3156, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3158, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3159, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(3160, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3157, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3159, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3160, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(3161, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3163, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3169, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(3170, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3162, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3164, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3170, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(3171, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3173, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3175, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3172, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3174, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(3176, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3178, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3179, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3180, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3177, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3179, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3180, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3181, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3183, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3184, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3185, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3182, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3184, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3185, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3186, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3188, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3194, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3195, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3187, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3189, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3195, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3196, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3198, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3204, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3205, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3197, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3199, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3205, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3206, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3208, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3209, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3210, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3207, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3209, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3210, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3211, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3213, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3219, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(3220, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3212, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3214, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3220, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(3221, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3223, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(3229, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(3230, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3222, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3224, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(3230, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(3231, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3233, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3234, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(3235, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3232, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3234, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3235, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(3236, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3238, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3244, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(3245, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3237, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3239, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3245, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(3246, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3248, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3254, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3255, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3247, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3249, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3255, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3256, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3258, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3259, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3260, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3257, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3259, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3260, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3261, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3263, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3269, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3270, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3262, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3264, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3270, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3271, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3273, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3289, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3290, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3291, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3292, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3293, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3294, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3295, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3296, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3297, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3301, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3302, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3303, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3304, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3305, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3306, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3307, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3308, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3309, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3310, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3311, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3312, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3316, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3317, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3318, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3334, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3335, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3336, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3337, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3338, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3339, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3340, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3341, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3342, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3346, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3347, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3348, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3364, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3365, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3366, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3367, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3368, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3369, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3370, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3371, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3372, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3376, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3377, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3378, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3379, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3380, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3381, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3382, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3383, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3384, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3385, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3386, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3387, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3391, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3392, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3393, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3409, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3410, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3411, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3412, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3413, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3414, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3415, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3416, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3417, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3421, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3422, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3423, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3439, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3440, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3441, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3442, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3443, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3444, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3445, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3446, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3447, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3451, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3452, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3453, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3454, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3455, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3456, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3457, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3458, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3459, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3460, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3461, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3462, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3466, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3467, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3468, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3484, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3485, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3486, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3487, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3488, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3489, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3490, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3491, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3492, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3496, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3497, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3498, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3514, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3515, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3516, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3517, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3518, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3519, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3520, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3521, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3522, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3526, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3527, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3528, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3529, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3530, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3531, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3532, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3533, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3534, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3535, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3536, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3537, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3541, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3542, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3543, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3559, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3560, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3561, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3562, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3563, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3564, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3565, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3566, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3567, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3571, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3572, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3573, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3577, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3578, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3579, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3580, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3581, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3582, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3586, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3587, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3588, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3589, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3590, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3591, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3592, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3593, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3594, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3595, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3596, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3597, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3601, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3602, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3603, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3604, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3605, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3606, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3607, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3608, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3609, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3610, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3611, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3612, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3616, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3617, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3618, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3634, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3635, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3636, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3637, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3638, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3639, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3640, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3641, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3642, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3646, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3647, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3648, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3652, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3653, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3654, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3655, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3656, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3657, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3661, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3662, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3663, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3664, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3665, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3666, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3667, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3668, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3669, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3670, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3671, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3672, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3676, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3677, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3678, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3679, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3680, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3681, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3682, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3683, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3684, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3685, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3686, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3687, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3691, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3692, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3693, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3709, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3710, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3711, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3712, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3713, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3714, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3715, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3716, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3717, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3721, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3722, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3723, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3727, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3728, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3729, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3730, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3731, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3732, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3736, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3737, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3738, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3739, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3740, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3741, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3742, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3743, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3744, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3745, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3746, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3747, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3751, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3752, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3753, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3754, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3755, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3756, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3757, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3758, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3759, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3760, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3761, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3762, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3766, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3767, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3768, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3784, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3785, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3786, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3787, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3788, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3789, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3790, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3791, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3792, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3796, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3797, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3798, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3802, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3803, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3804, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3805, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3806, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3807, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3811, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3812, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3813, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3814, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3815, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3816, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3817, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3818, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3819, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3820, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3821, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3822, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3826, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3827, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3828, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3829, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3830, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3831, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3832, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3833, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3834, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3835, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3836, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3837, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3841, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3842, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3843, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3859, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3860, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3861, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3862, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3863, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3864, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3865, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3866, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3867, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3871, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3872, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3873, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3874, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \ - _(3875, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \ - _(3876, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \ - _(3877, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED) \ - _(3878, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \ - _(3879, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \ - _(3880, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \ - _(3881, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \ - _(3882, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \ - _(3883, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED) \ - _(3884, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \ - _(3885, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \ - _(3886, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \ - _(3887, ZEND_POST_INC_LONG_SPEC_TMPVARCV) \ - _(3888, ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \ - _(3889, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \ - _(3890, ZEND_POST_DEC_LONG_SPEC_TMPVARCV) \ - _(3891, ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \ - _(3892, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(3893, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3272, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3274, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3290, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3291, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3292, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3293, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3294, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3295, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3296, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3297, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3298, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3302, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3303, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3304, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3305, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3306, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3307, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3308, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3309, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3310, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3311, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3312, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3313, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3317, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3318, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3319, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3335, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3336, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3337, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3338, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3339, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3340, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3341, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3342, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3343, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3347, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3348, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3349, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3365, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3366, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3367, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3368, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3369, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3370, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3371, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3372, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3373, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3377, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3378, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3379, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3380, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3381, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3382, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3383, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3384, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3385, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3386, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3387, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3388, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3392, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3393, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3394, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3410, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3411, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3412, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3413, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3414, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3415, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3416, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3417, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3418, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3422, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3423, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3424, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3440, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3441, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3442, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3443, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3444, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3445, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3446, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3447, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3448, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3452, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3453, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3454, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3455, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3456, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3457, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3458, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3459, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3460, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3461, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3462, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3463, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3467, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3468, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3469, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3485, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3486, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3487, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3488, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3489, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3490, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3491, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3492, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3493, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3497, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3498, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3499, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3515, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3516, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3517, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3518, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3519, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3520, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3521, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3522, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3523, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3527, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3528, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3529, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3530, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3531, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3532, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3533, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3534, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3535, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3536, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3537, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3538, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3542, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3543, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3544, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3560, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3561, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3562, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3563, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3564, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3565, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3566, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3567, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3568, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3572, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3573, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3574, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3578, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3579, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3580, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3581, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3582, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3583, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3587, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3588, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3589, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3590, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3591, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3592, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3593, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3594, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3595, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3596, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3597, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3598, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3602, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3603, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3604, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3605, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3606, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3607, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3608, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3609, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3610, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3611, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3612, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3613, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3617, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3618, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3619, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3635, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3636, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3637, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3638, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3639, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3640, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3641, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3642, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3643, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3647, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3648, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3649, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3653, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3654, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3655, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3656, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3657, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3658, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3662, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3663, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3664, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3665, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3666, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3667, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3668, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3669, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3670, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3671, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3672, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3673, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3677, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3678, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3679, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3680, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3681, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3682, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3683, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3684, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3685, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3686, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3687, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3688, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3692, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3693, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3694, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3710, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3711, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3712, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3713, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3714, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3715, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3716, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3717, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3718, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3722, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3723, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3724, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3728, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3729, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3730, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3731, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3732, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3733, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3737, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3738, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3739, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3740, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3741, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3742, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3743, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3744, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3745, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3746, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3747, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3748, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3752, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3753, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3754, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3755, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3756, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3757, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3758, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3759, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3760, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3761, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3762, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3763, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3767, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3768, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3769, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3785, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3786, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3787, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3788, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3789, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3790, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3791, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3792, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3793, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3797, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3798, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3799, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3803, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3804, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3805, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3806, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3807, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3808, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3812, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3813, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3814, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3815, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3816, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3817, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3818, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3819, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3820, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3821, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3822, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3823, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3827, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3828, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3829, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3830, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3831, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3832, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3833, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3834, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3835, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3836, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3837, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3838, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3842, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3843, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3844, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3860, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3861, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3862, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3863, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3864, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3865, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3866, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3867, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3868, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3872, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3873, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3874, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3875, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \ + _(3876, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \ + _(3877, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \ + _(3878, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED) \ + _(3879, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \ + _(3880, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \ + _(3881, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \ + _(3882, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \ + _(3883, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \ + _(3884, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED) \ + _(3885, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \ + _(3886, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \ + _(3887, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \ + _(3888, ZEND_POST_INC_LONG_SPEC_TMPVARCV) \ + _(3889, ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \ + _(3890, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \ + _(3891, ZEND_POST_DEC_LONG_SPEC_TMPVARCV) \ + _(3892, ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \ + _(3893, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ _(3894, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3896, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3897, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(3898, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3895, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3897, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3898, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ _(3899, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3901, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3903, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3900, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3902, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ _(3904, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3906, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3907, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3908, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3905, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3907, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3908, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ _(3909, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3911, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3912, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3913, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3910, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3912, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3913, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ _(3914, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3916, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3922, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(3923, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3915, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3917, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3923, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ _(3924, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3926, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3929, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3931, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3934, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \ - _(3936, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \ - _(3937, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3938, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3939, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3940, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3940+1, ZEND_NULL) + _(3925, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3927, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3930, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3932, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3935, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \ + _(3937, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \ + _(3938, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3939, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3940, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3941, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3941+1, ZEND_NULL) diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index 12d8fa8d679b8..dd2a05714180b 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -169,7 +169,7 @@ static const char *zend_vm_opcodes_names[200] = { "ZEND_DECLARE_CONST", NULL, "ZEND_DECLARE_INHERITED_CLASS_DELAYED", - NULL, + "ZEND_VERIFY_VARIANCE", "ZEND_ASSIGN_DIM", "ZEND_ISSET_ISEMPTY_PROP_OBJ", "ZEND_HANDLE_EXCEPTION", @@ -372,7 +372,7 @@ static uint32_t zend_vm_opcodes_flags[200] = { 0x00000303, 0x00000000, 0x00000303, - 0x00000000, + 0x00000103, 0x00006701, 0x00060757, 0x00000000, diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h index 922377b72b564..ef9fa49955f74 100644 --- a/Zend/zend_vm_opcodes.h +++ b/Zend/zend_vm_opcodes.h @@ -219,6 +219,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