From 1d3ded7f2721a5b5e6bc67489d1149f1b49179ff Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Mon, 10 Feb 2020 13:08:17 +0100 Subject: [PATCH] Add support for "decorated" properties --- Zend/tests/decorators/basic.phpt | 70 ++ .../decorators/decorated_incorrect_type.phpt | 12 + .../decorators/decorated_multiple_prop.phpt | 13 + Zend/tests/decorators/decorated_no_type.phpt | 12 + .../decorators/decorated_prop_group.phpt | 12 + .../decorated_prop_nonexistent_class.phpt | 12 + .../decorators/decorated_prop_not_set.phpt | 20 + Zend/zend.c | 8 + Zend/zend.h | 2 + Zend/zend_API.c | 7 +- Zend/zend_API.h | 2 +- Zend/zend_compile.c | 21 +- Zend/zend_compile.h | 6 + Zend/zend_globals.h | 1 + Zend/zend_inheritance.c | 78 +- Zend/zend_language_parser.y | 3 + Zend/zend_language_scanner.l | 4 + Zend/zend_opcode.c | 13 +- Zend/zend_vm_def.h | 129 +++ Zend/zend_vm_execute.h | 229 ++++- Zend/zend_vm_handlers.h | 898 +++++++++--------- Zend/zend_vm_opcodes.c | 8 +- Zend/zend_vm_opcodes.h | 4 +- ext/tokenizer/tokenizer_data.c | 6 +- 24 files changed, 1062 insertions(+), 508 deletions(-) create mode 100644 Zend/tests/decorators/basic.phpt create mode 100644 Zend/tests/decorators/decorated_incorrect_type.phpt create mode 100644 Zend/tests/decorators/decorated_multiple_prop.phpt create mode 100644 Zend/tests/decorators/decorated_no_type.phpt create mode 100644 Zend/tests/decorators/decorated_prop_group.phpt create mode 100644 Zend/tests/decorators/decorated_prop_nonexistent_class.phpt create mode 100644 Zend/tests/decorators/decorated_prop_not_set.phpt diff --git a/Zend/tests/decorators/basic.phpt b/Zend/tests/decorators/basic.phpt new file mode 100644 index 0000000000000..dd7b4451976fc --- /dev/null +++ b/Zend/tests/decorators/basic.phpt @@ -0,0 +1,70 @@ +--TEST-- +Basic decorator test +--FILE-- +component = $component; + } + public function getName(): string { + return "DecoratedComponent({$this->component->getName()})"; + } + public function getValue1(): int { + return $this->component->getValue1() + 1; + } +} + +class ExtendDecoratedComponent extends DecoratedComponent { + public function getValue1(): int { + return parent::getValue1() + 1; + } + public function getValue2(string $prefix): string { + return parent::getValue2($prefix) . "bar"; + } +} + +$baseComponent = new ConcreteBaseComponent; +var_dump($baseComponent->getName()); +var_dump($baseComponent->getValue1()); +var_dump($baseComponent->getValue2("prefix: ")); +$decorated = new DecoratedComponent($baseComponent); +var_dump($decorated->getName()); +var_dump($decorated->getValue1()); +var_dump($decorated->getValue2("prefix: ")); +$decorated = new ExtendDecoratedComponent($baseComponent); +var_dump($decorated->getName()); +var_dump($decorated->getValue1()); +var_dump($decorated->getValue2("prefix: ")); + +?> +--EXPECT-- +string(21) "ConcreteBaseComponent" +int(42) +string(11) "prefix: foo" +string(41) "DecoratedComponent(ConcreteBaseComponent)" +int(43) +string(11) "prefix: foo" +string(41) "DecoratedComponent(ConcreteBaseComponent)" +int(44) +string(14) "prefix: foobar" diff --git a/Zend/tests/decorators/decorated_incorrect_type.phpt b/Zend/tests/decorators/decorated_incorrect_type.phpt new file mode 100644 index 0000000000000..ad81b7267c67c --- /dev/null +++ b/Zend/tests/decorators/decorated_incorrect_type.phpt @@ -0,0 +1,12 @@ +--TEST-- +Decorated property illegal type +--FILE-- + +--EXPECTF-- +Fatal error: Decorator property must have exactly one class type in %s on line %d diff --git a/Zend/tests/decorators/decorated_multiple_prop.phpt b/Zend/tests/decorators/decorated_multiple_prop.phpt new file mode 100644 index 0000000000000..9e485c28fd7e8 --- /dev/null +++ b/Zend/tests/decorators/decorated_multiple_prop.phpt @@ -0,0 +1,13 @@ +--TEST-- +Cannot use "decorated" on multiple properties +--FILE-- + +--EXPECTF-- +Fatal error: Cannot declare multiple properties as "decorated" in %s on line %d diff --git a/Zend/tests/decorators/decorated_no_type.phpt b/Zend/tests/decorators/decorated_no_type.phpt new file mode 100644 index 0000000000000..cec696ca7dffb --- /dev/null +++ b/Zend/tests/decorators/decorated_no_type.phpt @@ -0,0 +1,12 @@ +--TEST-- +Decorated property without type +--FILE-- + +--EXPECTF-- +Fatal error: Decorator property must have exactly one class type in %s on line %d diff --git a/Zend/tests/decorators/decorated_prop_group.phpt b/Zend/tests/decorators/decorated_prop_group.phpt new file mode 100644 index 0000000000000..acaa099a66895 --- /dev/null +++ b/Zend/tests/decorators/decorated_prop_group.phpt @@ -0,0 +1,12 @@ +--TEST-- +Cannot use "decorated" with property group +--FILE-- + +--EXPECTF-- +Fatal error: Cannot declare multiple properties as "decorated" in %s on line %d diff --git a/Zend/tests/decorators/decorated_prop_nonexistent_class.phpt b/Zend/tests/decorators/decorated_prop_nonexistent_class.phpt new file mode 100644 index 0000000000000..771518c59a854 --- /dev/null +++ b/Zend/tests/decorators/decorated_prop_nonexistent_class.phpt @@ -0,0 +1,12 @@ +--TEST-- +Decorated property references non-existing class +--FILE-- + +--EXPECTF-- +Fatal error: Class 'DoesntExist' not found in %s on line %d diff --git a/Zend/tests/decorators/decorated_prop_not_set.phpt b/Zend/tests/decorators/decorated_prop_not_set.phpt new file mode 100644 index 0000000000000..13921284059f7 --- /dev/null +++ b/Zend/tests/decorators/decorated_prop_not_set.phpt @@ -0,0 +1,20 @@ +--TEST-- +The decorated proprety has not been set +--FILE-- +valid()); +} catch (Error $e) { + echo $e->getMessage(), "\n"; +} + +?> +--EXPECT-- +Typed property DecoratedIterator::$it must not be accessed before initialization diff --git a/Zend/zend.c b/Zend/zend.c index 9f3c05f973248..d84c6e7f63e70 100644 --- a/Zend/zend.c +++ b/Zend/zend.c @@ -555,9 +555,17 @@ static void zend_init_exception_op(void) /* {{{ */ static void zend_init_call_trampoline_op(void) /* {{{ */ { + zend_op *decorated_ops = EG(call_decorated_ops); + memset(&EG(call_trampoline_op), 0, sizeof(EG(call_trampoline_op))); EG(call_trampoline_op).opcode = ZEND_CALL_TRAMPOLINE; ZEND_VM_SET_OPCODE_HANDLER(&EG(call_trampoline_op)); + + memset(decorated_ops, 0, sizeof(EG(call_decorated_ops))); + decorated_ops[0].opcode = ZEND_CALL_DECORATED; + ZEND_VM_SET_OPCODE_HANDLER(&decorated_ops[0]); + decorated_ops[1].opcode = ZEND_RETURN_DECORATED; + ZEND_VM_SET_OPCODE_HANDLER(&decorated_ops[1]); } /* }}} */ diff --git a/Zend/zend.h b/Zend/zend.h index b965a765e35f9..3032334f2ef2c 100644 --- a/Zend/zend.h +++ b/Zend/zend.h @@ -171,6 +171,8 @@ struct _zend_class_entry { zend_trait_alias **trait_aliases; zend_trait_precedence **trait_precedences; + struct _zend_property_info *decorated_prop; + union { struct { zend_string *filename; diff --git a/Zend/zend_API.c b/Zend/zend_API.c index f826af856d58a..185007ab32c98 100644 --- a/Zend/zend_API.c +++ b/Zend/zend_API.c @@ -3476,7 +3476,7 @@ static zend_always_inline zend_bool is_persistent_class(zend_class_entry *ce) { && ce->info.internal.module->type == MODULE_PERSISTENT; } -ZEND_API int zend_declare_typed_property(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment, zend_type type) /* {{{ */ +ZEND_API zend_property_info *zend_declare_typed_property(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment, zend_type type) /* {{{ */ { zend_property_info *property_info, *property_info_ptr; @@ -3579,8 +3579,7 @@ ZEND_API int zend_declare_typed_property(zend_class_entry *ce, zend_string *name property_info->type = type; zend_hash_update_ptr(&ce->properties_info, name, property_info); - - return SUCCESS; + return property_info; } /* }}} */ @@ -3713,7 +3712,7 @@ ZEND_API int zend_try_assign_typed_ref_zval_ex(zend_reference *ref, zval *zv, ze ZEND_API int zend_declare_property_ex(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment) /* {{{ */ { - return zend_declare_typed_property(ce, name, property, access_type, doc_comment, (zend_type) ZEND_TYPE_INIT_NONE(0)); + return zend_declare_typed_property(ce, name, property, access_type, doc_comment, (zend_type) ZEND_TYPE_INIT_NONE(0)) ? SUCCESS : FAILURE; } /* }}} */ diff --git a/Zend/zend_API.h b/Zend/zend_API.h index 70879fe2a8013..9e3c18d438999 100644 --- a/Zend/zend_API.h +++ b/Zend/zend_API.h @@ -333,7 +333,7 @@ ZEND_API zend_bool zend_make_callable(zval *callable, zend_string **callable_nam ZEND_API const char *zend_get_module_version(const char *module_name); ZEND_API int zend_get_module_started(const char *module_name); -ZEND_API int zend_declare_typed_property(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment, zend_type type); +ZEND_API zend_property_info *zend_declare_typed_property(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment, zend_type type); ZEND_API int zend_declare_property_ex(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment); ZEND_API int zend_declare_property(zend_class_entry *ce, const char *name, size_t name_length, zval *property, int access_type); diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index d17185fbb8a5a..284a393a7ab52 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -1849,6 +1849,7 @@ ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify ce->serialize_func = NULL; ce->unserialize_func = NULL; ce->__debugInfo = NULL; + ce->decorated_prop = NULL; if (ce->type == ZEND_INTERNAL_CLASS) { ce->info.internal.module = NULL; ce->info.internal.builtin_functions = NULL; @@ -6375,7 +6376,21 @@ void zend_compile_prop_decl(zend_ast *ast, zend_ast *type_ast, uint32_t flags) / ZVAL_UNDEF(&value_zv); } - zend_declare_typed_property(ce, name, &value_zv, flags, doc_comment, type); + zend_property_info *prop_info = + zend_declare_typed_property(ce, name, &value_zv, flags, doc_comment, type); + + if (flags & ZEND_ACC_DECORATED) { + if (ce->decorated_prop) { + zend_error_noreturn(E_COMPILE_ERROR, + "Cannot declare multiple properties as \"decorated\""); + } + ce->decorated_prop = prop_info; + + if (!ZEND_TYPE_HAS_NAME(type) || ZEND_TYPE_PURE_MASK(type) != 0) { + zend_error_noreturn(E_COMPILE_ERROR, + "Decorator property must have exactly one class type"); + } + } } } /* }}} */ @@ -6690,7 +6705,7 @@ zend_op *zend_compile_class_decl(zend_ast *ast, zend_bool toplevel) /* {{{ */ if (toplevel /* We currently don't early-bind classes that implement interfaces or use traits */ - && !ce->num_interfaces && !ce->num_traits + && !ce->num_interfaces && !ce->num_traits && !ce->decorated_prop && !(CG(compiler_options) & ZEND_COMPILE_PRELOAD)) { if (extends_ast) { zend_class_entry *parent_ce = zend_lookup_class_ex( @@ -6751,7 +6766,7 @@ zend_op *zend_compile_class_decl(zend_ast *ast, zend_bool toplevel) /* {{{ */ if (extends_ast && toplevel && (CG(compiler_options) & ZEND_COMPILE_DELAYED_BINDING) /* We currently don't early-bind classes that implement interfaces or use traits */ - && !ce->num_interfaces && !ce->num_traits + && !ce->num_interfaces && !ce->num_traits && !ce->decorated_prop ) { CG(active_op_array)->fn_flags |= ZEND_ACC_EARLY_BINDING; opline->opcode = ZEND_DECLARE_CLASS_DELAYED; diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index 6c438b6902b59..73c99b4b99e42 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -229,6 +229,12 @@ typedef struct _zend_oparray_context { /* op_array or class is preloaded | | | */ #define ZEND_ACC_PRELOADED (1 << 10) /* X | X | | */ /* | | | */ +/* Property Flags (unused: 8...) | | | */ +/* =========== | | | */ +/* | | | */ +/* Decorated property | | | */ +#define ZEND_ACC_DECORATED (1 << 7) /* | | X | */ +/* | | | */ /* Class Flags (unused: 13, 14, 15, 24...) | | | */ /* =========== | | | */ /* | | | */ diff --git a/Zend/zend_globals.h b/Zend/zend_globals.h index 2dc769a5efe17..0e1ff245b6648 100644 --- a/Zend/zend_globals.h +++ b/Zend/zend_globals.h @@ -233,6 +233,7 @@ struct _zend_executor_globals { zend_function trampoline; zend_op call_trampoline_op; + zend_op call_decorated_ops[2]; HashTable weakrefs; diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index 5abe1c55d4a0c..8e33a7d650253 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -2201,6 +2201,80 @@ void zend_verify_abstract_class(zend_class_entry *ce) /* {{{ */ } /* }}} */ +static zend_op_array *create_decorator_op_array(zend_class_entry *ce, zend_function *orig_func) +{ + /* We use non-NULL value to avoid useless run_time_cache allocation. + * The low bit must be zero, to not be interpreted as a MAP_PTR offset. */ + static const void *dummy = (void*)(intptr_t)2; + + uint32_t preserve_flags = ZEND_ACC_HAS_TYPE_HINTS|ZEND_ACC_HAS_RETURN_TYPE; + + zend_op_array *func = zend_arena_alloc(&CG(arena), sizeof(zend_op_array)); + memset(func, 0, sizeof(zend_op_array)); + + func->refcount = (uint32_t *) emalloc(sizeof(uint32_t)); + *func->refcount = 1; + + func->type = ZEND_USER_FUNCTION; + func->fn_flags = ZEND_ACC_PUBLIC; + func->fn_flags |= orig_func->common.fn_flags & preserve_flags; + func->function_name = zend_string_copy(orig_func->common.function_name); + func->scope = ce; + func->num_args = orig_func->common.num_args; + func->required_num_args = orig_func->common.required_num_args; + func->arg_info = orig_func->common.arg_info; + + /* Place the method at position of the class declaration, + * as we don't have any more accurate location information. */ + func->filename = ce->info.user.filename; + func->line_start = ce->info.user.line_start; + func->line_end = ce->info.user.line_start; + + func->opcodes = EG(call_decorated_ops); + ZEND_MAP_PTR_INIT(func->run_time_cache, (void***)&dummy); + + return func; +} + +static void zend_decorate_class(zend_class_entry *ce) +{ + zend_property_info *prop = ce->decorated_prop; + + zend_class_entry *decorated_ce; + if (ZEND_TYPE_HAS_NAME(prop->type)) { + /* TODO: Allow exception here? */ + zend_string *decorated_name = ZEND_TYPE_NAME(prop->type); + decorated_ce = zend_fetch_class_by_name(decorated_name, NULL, 0); + ZEND_TYPE_SET_CE(prop->type, decorated_ce); + zend_string_release(decorated_name); + } else if (ZEND_TYPE_HAS_CE(prop->type)) { + decorated_ce = ZEND_TYPE_CE(prop->type); + } else { + ZEND_ASSERT(0 && "Decorated property must have single class type"); + } + + zend_string *lcname; + zend_function *func; + ZEND_HASH_FOREACH_STR_KEY_PTR(&decorated_ce->function_table, lcname, func) { + /* Only the public interface of the decorated class is proxied. */ + if (!(func->common.fn_flags & ZEND_ACC_PUBLIC)) { + continue; + } + + /* Static methods are not proxied. */ + if (func->common.fn_flags & ZEND_ACC_STATIC) { + continue; + } + + /* The method was explicitly overridden in the class, skip. */ + if (zend_hash_find(&ce->function_table, lcname)) { + continue; + } + + zend_hash_add_new_ptr(&ce->function_table, lcname, create_decorator_op_array(ce, func)); + } ZEND_HASH_FOREACH_END(); +} + typedef struct { enum { OBLIGATION_DEPENDENCY, @@ -2453,7 +2527,9 @@ ZEND_API int zend_do_link_class(zend_class_entry *ce, zend_string *lc_parent_nam interfaces[num_parent_interfaces + i] = iface; } } - + if (ce->decorated_prop) { + zend_decorate_class(ce); + } if (parent) { if (!(parent->ce_flags & ZEND_ACC_LINKED)) { add_dependency_obligation(ce, parent); diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y index 078c863c4ee6f..ea703c384673e 100644 --- a/Zend/zend_language_parser.y +++ b/Zend/zend_language_parser.y @@ -156,6 +156,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %token T_FOREACH "foreach (T_FOREACH)" %token T_ENDFOREACH "endforeach (T_ENDFOREACH)" %token T_DECLARE "declare (T_DECLARE)" +%token T_DECORATED "decorated (T_DECORATED)" %token T_ENDDECLARE "enddeclare (T_ENDDECLARE)" %token T_AS "as (T_AS)" %token T_SWITCH "switch (T_SWITCH)" @@ -797,6 +798,8 @@ method_body: variable_modifiers: non_empty_member_modifiers { $$ = $1; } + | non_empty_member_modifiers T_DECORATED + { $$ = $1 | ZEND_ACC_DECORATED; } | T_VAR { $$ = ZEND_ACC_PUBLIC; } ; diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l index 0c066c52ab304..8f8450e628fe9 100644 --- a/Zend/zend_language_scanner.l +++ b/Zend/zend_language_scanner.l @@ -1370,6 +1370,10 @@ NEWLINE ("\r"|"\n"|"\r\n") RETURN_TOKEN(T_ENDDECLARE); } +"decorated" { + RETURN_TOKEN(T_DECORATED); +} + "instanceof" { RETURN_TOKEN(T_INSTANCEOF); } diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c index 881626b71e487..14589210555c6 100644 --- a/Zend/zend_opcode.c +++ b/Zend/zend_opcode.c @@ -453,6 +453,15 @@ ZEND_API void destroy_op_array(zend_op_array *op_array) efree_size(op_array->refcount, sizeof(*(op_array->refcount))); + if (op_array->function_name) { + zend_string_release_ex(op_array->function_name, 0); + } + + /* Uses shared opcodes and arginfo. Don't free past here. */ + if (op_array->opcodes == EG(call_decorated_ops)) { + return; + } + if (op_array->vars) { i = op_array->last_var; while (i > 0) { @@ -474,11 +483,9 @@ ZEND_API void destroy_op_array(zend_op_array *op_array) efree(op_array->literals); } } + efree(op_array->opcodes); - if (op_array->function_name) { - zend_string_release_ex(op_array->function_name, 0); - } if (op_array->doc_comment) { zend_string_release_ex(op_array->doc_comment, 0); } diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index b766bf24694fc..f15fa5468d093 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -8159,6 +8159,135 @@ ZEND_VM_HANDLER(158, ZEND_CALL_TRAMPOLINE, ANY, ANY) ZEND_VM_LEAVE(); } +/* Forwards to the generated method. Note that unlike CALL_TRAMPOLINE, this is going to insert + * a proper stack frame. */ +ZEND_VM_HANDLER(195, ZEND_CALL_DECORATED, ANY, ANY) +{ + zend_function *func = EX(func); + zend_class_entry *ce = func->common.scope; + zend_property_info *prop = ce->decorated_prop; + zval *decorated_zv = OBJ_PROP(Z_OBJ(EX(This)), prop->offset); + + SAVE_OPLINE(); + if (UNEXPECTED(Z_ISUNDEF_P(decorated_zv))) { + zend_throw_error(NULL, "Typed property %s::$%s must not be accessed before initialization", + ZSTR_VAL(prop->ce->name), + zend_get_unmangled_property_name(prop->name)); + HANDLE_EXCEPTION(); + } + + zend_object *decorated_obj = Z_OBJ_P(decorated_zv); + zend_class_entry *decorated_ce = decorated_obj->ce; + + // TODO: What's a good way to cache this? + zend_string *lcname = zend_string_tolower(func->common.function_name); + zend_function *fbc = zend_hash_find_ptr(&decorated_ce->function_table, lcname); + zend_string_release(lcname); + + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + } + + uint32_t num_args = EX_NUM_ARGS(); + uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + zval *ret = EX(return_value); + zend_execute_data *call = + zend_vm_stack_push_call_frame(call_info, fbc, num_args, decorated_obj); + + if (num_args) { + zval *p = ZEND_CALL_ARG(execute_data, 1); + zval *q = ZEND_CALL_ARG(call, 1); + zval *end = p + num_args; + + for (; p < end; p++, q++) { + ZVAL_COPY(q, p); + } + } + + /* The following is essentially copied from DO_FCALL. */ + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) { + call->prev_execute_data = execute_data; + execute_data = call; + i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); + + if (EXPECTED(zend_execute_ex == execute_ex)) { + LOAD_OPLINE_EX(); + ZEND_VM_ENTER_EX(); + } else { + SAVE_OPLINE_EX(); + execute_data = EX(prev_execute_data); + LOAD_OPLINE(); + ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP); + zend_execute_ex(call); + } + } else { + zval retval; + ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION); + + if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) { + zend_deprecated_function(fbc); + if (UNEXPECTED(EG(exception) != NULL)) { + UNDEF_RESULT(); + if (!RETURN_VALUE_USED(opline)) { + ret = &retval; + ZVAL_UNDEF(ret); + } + ZEND_VM_C_GOTO(decorated_fcall_end); + } + } + + call->prev_execute_data = execute_data; + EG(current_execute_data) = call; + +#if ZEND_DEBUG + zend_bool should_throw = zend_internal_call_should_throw(fbc, call); +#endif + + ZVAL_NULL(ret); + if (!zend_execute_internal) { + /* saves one function call if zend_execute_internal is not used */ + fbc->internal_function.handler(call, ret); + } else { + zend_execute_internal(call, ret); + } + +#if ZEND_DEBUG + if (!EG(exception) && call->func) { + if (should_throw) { + zend_internal_call_arginfo_violation(call->func); + } + ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || + zend_verify_internal_return_type(call->func, ret)); + ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) + ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); + } +#endif + + EG(current_execute_data) = execute_data; + +ZEND_VM_C_LABEL(decorated_fcall_end): + zend_vm_stack_free_args(call); + if (!RETURN_VALUE_USED(opline)) { + i_zval_ptr_dtor(ret); + } + } + + zend_vm_stack_free_call_frame(call); + if (UNEXPECTED(EG(exception) != NULL)) { + zend_rethrow_exception(execute_data); + HANDLE_EXCEPTION(); + } + + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); +} + +ZEND_VM_HANDLER(196, ZEND_RETURN_DECORATED, ANY, ANY) +{ + /* EX(return_value) is already populated, return directly. */ + ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper); +} + ZEND_VM_HANDLER(182, ZEND_BIND_LEXICAL, TMP, CV, REF) { USE_OPLINE diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 58e97b2116ca6..f2d2486f1d523 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -2820,6 +2820,135 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(Z ZEND_VM_LEAVE(); } +/* Forwards to the generated method. Note that unlike CALL_TRAMPOLINE, this is going to insert + * a proper stack frame. */ +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_DECORATED_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + zend_function *func = EX(func); + zend_class_entry *ce = func->common.scope; + zend_property_info *prop = ce->decorated_prop; + zval *decorated_zv = OBJ_PROP(Z_OBJ(EX(This)), prop->offset); + + SAVE_OPLINE(); + if (UNEXPECTED(Z_ISUNDEF_P(decorated_zv))) { + zend_throw_error(NULL, "Typed property %s::$%s must not be accessed before initialization", + ZSTR_VAL(prop->ce->name), + zend_get_unmangled_property_name(prop->name)); + HANDLE_EXCEPTION(); + } + + zend_object *decorated_obj = Z_OBJ_P(decorated_zv); + zend_class_entry *decorated_ce = decorated_obj->ce; + + // TODO: What's a good way to cache this? + zend_string *lcname = zend_string_tolower(func->common.function_name); + zend_function *fbc = zend_hash_find_ptr(&decorated_ce->function_table, lcname); + zend_string_release(lcname); + + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + } + + uint32_t num_args = EX_NUM_ARGS(); + uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + zval *ret = EX(return_value); + zend_execute_data *call = + zend_vm_stack_push_call_frame(call_info, fbc, num_args, decorated_obj); + + if (num_args) { + zval *p = ZEND_CALL_ARG(execute_data, 1); + zval *q = ZEND_CALL_ARG(call, 1); + zval *end = p + num_args; + + for (; p < end; p++, q++) { + ZVAL_COPY(q, p); + } + } + + /* The following is essentially copied from DO_FCALL. */ + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) { + call->prev_execute_data = execute_data; + execute_data = call; + i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC); + + if (EXPECTED(zend_execute_ex == execute_ex)) { + LOAD_OPLINE_EX(); + ZEND_VM_ENTER_EX(); + } else { + SAVE_OPLINE_EX(); + execute_data = EX(prev_execute_data); + LOAD_OPLINE(); + ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP); + zend_execute_ex(call); + } + } else { + zval retval; + ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION); + + if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) { + zend_deprecated_function(fbc); + if (UNEXPECTED(EG(exception) != NULL)) { + UNDEF_RESULT(); + if (!RETURN_VALUE_USED(opline)) { + ret = &retval; + ZVAL_UNDEF(ret); + } + goto decorated_fcall_end; + } + } + + call->prev_execute_data = execute_data; + EG(current_execute_data) = call; + +#if ZEND_DEBUG + zend_bool should_throw = zend_internal_call_should_throw(fbc, call); +#endif + + ZVAL_NULL(ret); + if (!zend_execute_internal) { + /* saves one function call if zend_execute_internal is not used */ + fbc->internal_function.handler(call, ret); + } else { + zend_execute_internal(call, ret); + } + +#if ZEND_DEBUG + if (!EG(exception) && call->func) { + if (should_throw) { + zend_internal_call_arginfo_violation(call->func); + } + ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) || + zend_verify_internal_return_type(call->func, ret)); + ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) + ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); + } +#endif + + EG(current_execute_data) = execute_data; + +decorated_fcall_end: + zend_vm_stack_free_args(call); + if (!RETURN_VALUE_USED(opline)) { + i_zval_ptr_dtor(ret); + } + } + + zend_vm_stack_free_call_frame(call); + if (UNEXPECTED(EG(exception) != NULL)) { + zend_rethrow_exception(execute_data); + HANDLE_EXCEPTION(); + } + + ZEND_VM_SET_OPCODE(opline + 1); + ZEND_VM_CONTINUE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_DECORATED_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + /* EX(return_value) is already populated, return directly. */ + ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); +} + static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_FORWARD_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -50767,6 +50896,8 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_LABEL, + (void*)&&ZEND_CALL_DECORATED_SPEC_LABEL, + (void*)&&ZEND_RETURN_DECORATED_SPEC_LABEL, (void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL, (void*)&&ZEND_JMP_FORWARD_SPEC_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -52002,6 +52133,14 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_CALL_TRAMPOLINE_SPEC) ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_CALL_DECORATED_SPEC): + VM_TRACE(ZEND_CALL_DECORATED_SPEC) + ZEND_CALL_DECORATED_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); + HYBRID_CASE(ZEND_RETURN_DECORATED_SPEC): + VM_TRACE(ZEND_RETURN_DECORATED_SPEC) + ZEND_RETURN_DECORATED_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_JMP_FORWARD_SPEC): VM_TRACE(ZEND_JMP_FORWARD_SPEC) ZEND_JMP_FORWARD_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -58299,6 +58438,8 @@ void zend_vm_init(void) ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER, + ZEND_CALL_DECORATED_SPEC_HANDLER, + ZEND_RETURN_DECORATED_SPEC_HANDLER, ZEND_RECV_NOTYPE_SPEC_HANDLER, ZEND_JMP_FORWARD_SPEC_HANDLER, ZEND_NULL_HANDLER, @@ -59400,7 +59541,9 @@ void zend_vm_init(void) 2280, 2281 | SPEC_RULE_OP1, 2286 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3214 + 2311, + 2312, + 3216 }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -59560,7 +59703,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 = 2313 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2315 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -59568,7 +59711,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 = 2338 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2340 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -59576,7 +59719,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 = 2363 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2365 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -59587,17 +59730,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 = 2388 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2390 | 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 = 2413 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2415 | 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 = 2438 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2440 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -59608,17 +59751,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 = 2463 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2465 | 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 = 2488 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2490 | 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 = 2513 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2515 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -59629,14 +59772,14 @@ 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 = 2538 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2540 | 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 = 2613 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2615 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 2838 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2840 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -59647,14 +59790,14 @@ 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 = 2688 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2690 | 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 = 2763 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2765 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 2843 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2845 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -59665,12 +59808,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 = 2538 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2540 | 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 = 2613 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2615 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -59681,12 +59824,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 = 2688 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2690 | 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 = 2763 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2765 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -59694,12 +59837,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 = 2848 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 2850 | 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 = 2923 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 2925 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -59707,74 +59850,74 @@ 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 = 2998 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3000 | 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 = 3073 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3075 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3160 | SPEC_RULE_OP1; + spec = 3162 | SPEC_RULE_OP1; } else if (op1_info == MAY_BE_DOUBLE) { - spec = 3165 | SPEC_RULE_OP1; + spec = 3167 | 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 = 3170 | SPEC_RULE_OP1; + spec = 3172 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3148 | SPEC_RULE_RETVAL; - } else if (op1_info == MAY_BE_LONG) { spec = 3150 | SPEC_RULE_RETVAL; + } else if (op1_info == MAY_BE_LONG) { + spec = 3152 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3152 | SPEC_RULE_RETVAL; - } else if (op1_info == MAY_BE_LONG) { spec = 3154 | SPEC_RULE_RETVAL; + } else if (op1_info == MAY_BE_LONG) { + spec = 3156 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3156; + spec = 3158; } else if (op1_info == MAY_BE_LONG) { - spec = 3157; + spec = 3159; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3158; + spec = 3160; } else if (op1_info == MAY_BE_LONG) { - spec = 3159; + spec = 3161; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2312; + spec = 2314; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2311; + spec = 2313; } break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3210; + spec = 3212; } break; case ZEND_SEND_VAR_EX: if (op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3205 | SPEC_RULE_OP1; + spec = 3207 | 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 = 3212 | SPEC_RULE_RETVAL; + spec = 3214 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -59782,17 +59925,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 = 3175 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3177 | 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 = 3211; + spec = 3213; } break; case ZEND_SEND_VAR: if ((op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3200 | SPEC_RULE_OP1; + spec = 3202 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 8a6dbe9c1996a..5aafe527d2a72 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -1284,498 +1284,500 @@ _(2307, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ _(2308, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ _(2310, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ - _(2311, ZEND_RECV_NOTYPE_SPEC) \ - _(2312, ZEND_JMP_FORWARD_SPEC) \ - _(2318, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2319, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2320, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2311, ZEND_CALL_DECORATED_SPEC) \ + _(2312, ZEND_RETURN_DECORATED_SPEC) \ + _(2313, ZEND_RECV_NOTYPE_SPEC) \ + _(2314, ZEND_JMP_FORWARD_SPEC) \ + _(2320, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2321, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2322, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2323, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2324, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2325, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2325, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2326, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2327, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2333, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2334, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2335, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2329, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2335, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2336, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2337, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2343, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2344, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2345, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2339, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2345, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2346, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2347, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2348, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(2349, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2350, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2350, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2351, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2352, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2358, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2359, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2360, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2354, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2360, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2361, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2362, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2368, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2369, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2370, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2364, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2370, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2371, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2372, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2373, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2374, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2375, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2375, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2376, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2377, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2383, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2384, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2385, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2379, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2385, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2386, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2387, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2389, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2390, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2389, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2391, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ _(2392, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2393, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2394, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2395, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2394, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2395, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2396, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2397, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2398, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2399, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2400, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2400, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2401, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2402, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2408, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2409, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2410, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2404, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2410, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2411, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2412, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2414, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2415, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2414, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2416, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ _(2417, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2418, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2419, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2420, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2419, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2420, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2421, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2422, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2423, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(2424, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2425, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2425, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2426, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2427, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2433, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2434, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2435, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2429, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2435, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2436, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2437, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2439, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2440, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2439, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2441, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ _(2442, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2443, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2444, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2445, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2444, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2445, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2446, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2447, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2448, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2449, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2450, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2450, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2451, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2452, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2458, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2459, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2460, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2454, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2460, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2461, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2462, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2468, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2469, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2470, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2464, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2470, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2471, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2472, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2473, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2474, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2475, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2475, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2476, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2477, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2483, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2484, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2485, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2479, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2485, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2486, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2487, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2493, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2494, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2495, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2489, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2495, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2496, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2497, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2498, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(2499, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2500, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2500, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2501, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2502, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2508, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2509, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2510, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2504, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2510, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2511, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2512, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2518, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2519, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2520, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2514, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2520, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2521, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2522, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2523, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2524, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2525, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2525, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2526, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2527, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2533, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2534, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2535, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2529, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2535, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2536, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2537, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2553, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2554, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2555, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2556, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2557, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2558, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2559, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2560, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2561, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2565, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2566, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2567, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2568, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2569, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2570, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2571, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2572, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2573, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2574, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2575, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2576, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2580, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2581, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2582, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2598, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2599, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2600, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2601, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2602, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2603, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2604, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2605, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2606, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2610, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2611, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2612, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2628, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2629, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2630, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2631, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2632, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2633, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2634, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2635, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2636, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2640, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2641, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2642, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2643, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2644, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2645, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2646, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2647, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2648, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2649, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2650, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2651, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2655, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2656, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2657, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2673, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2674, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2675, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2676, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2677, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2678, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2679, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2680, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2681, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2685, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2686, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2687, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2703, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2704, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2705, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2706, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2707, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2708, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2709, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2710, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2711, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2715, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2716, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2717, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2718, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2719, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2720, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2721, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2722, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2723, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2724, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2725, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2726, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2730, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2731, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2732, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2748, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2749, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2750, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2751, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2752, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2753, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2754, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2755, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2756, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2760, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2761, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2762, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2778, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2779, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2780, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2781, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2782, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2783, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2784, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2785, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2786, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2790, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2791, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2792, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2793, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2794, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2795, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2796, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2797, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2798, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2799, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2800, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2801, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2805, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2806, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2807, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2823, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2824, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2825, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2826, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2827, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2828, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2829, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2830, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2831, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2835, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2836, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2837, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2838, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(2842, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(2843, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(2847, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(2851, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(2852, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2853, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2854, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(2855, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2856, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2860, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(2861, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2862, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2863, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(2864, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2865, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2866, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2867, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2868, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2869, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2870, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2871, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2875, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2876, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2877, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2878, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(2879, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2880, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2881, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2882, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2883, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2884, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2885, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2886, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2890, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2891, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2892, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2908, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(2909, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2910, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2911, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2912, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2913, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2914, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2915, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2916, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2920, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2921, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2922, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2926, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2927, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2928, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2929, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2930, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2931, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2935, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2936, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2937, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2938, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2939, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2940, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2941, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2942, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2943, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2944, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2945, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2946, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2950, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2951, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2952, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2953, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2954, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2955, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2956, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2957, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2958, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2959, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2960, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2961, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2965, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2966, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2967, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2983, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2984, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2985, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2986, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2987, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2988, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2989, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2990, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2991, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2995, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2996, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2997, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3001, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3002, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3003, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3004, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3005, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3006, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3010, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3011, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3012, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3013, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3014, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3015, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3016, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3017, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3018, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3019, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3020, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3021, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3025, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3026, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3027, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3028, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3029, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3030, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3031, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3032, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3033, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3034, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3035, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3036, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3040, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3041, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3042, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3058, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3059, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3060, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3061, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3062, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3063, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3064, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3065, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3066, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3070, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3071, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3072, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3076, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3077, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3078, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3079, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3080, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3081, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3085, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3086, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3087, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3088, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3089, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3090, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3091, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3092, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3093, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3094, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3095, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3096, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3100, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3101, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3102, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3103, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3104, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3105, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3106, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3107, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3108, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3109, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3110, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3111, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3115, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3116, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3117, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3133, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3134, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3135, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3136, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3137, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3138, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3139, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3140, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3141, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3145, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3146, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3147, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3148, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3149, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3150, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3151, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3152, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3153, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3154, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3155, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3156, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3157, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3158, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3159, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3160, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ - _(3161, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3162, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(2539, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2555, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2556, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2557, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2558, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2559, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2560, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2561, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2562, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2563, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2567, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2568, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2569, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2570, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2571, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2572, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2573, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2574, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2575, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2576, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2577, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2578, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2582, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2583, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2584, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2600, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2601, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2602, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2603, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2604, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2605, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2606, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2607, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2608, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2612, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2613, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2614, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2630, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2631, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2632, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2633, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2634, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2635, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2636, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2637, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2638, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2642, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2643, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2644, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2645, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2646, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2647, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2648, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2649, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2650, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2651, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2652, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2653, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2657, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2658, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2659, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2675, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2676, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2677, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2678, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2679, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2680, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2681, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2682, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2683, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2687, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2688, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2689, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2705, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2706, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2707, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2708, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2709, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2710, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2711, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2712, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2713, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2717, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2718, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2719, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2720, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2721, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2722, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2723, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2724, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2725, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2726, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2727, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2728, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2732, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2733, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2734, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2750, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2751, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2752, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2753, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2754, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2755, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2756, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2757, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2758, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2762, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2763, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2764, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2780, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2781, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2782, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2783, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2784, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2785, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2786, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2787, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2788, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2792, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2793, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2794, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2795, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2796, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2797, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2798, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2799, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2800, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2801, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2802, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2803, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2807, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2808, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2809, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2825, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2826, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2827, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2828, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2829, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2830, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2831, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2832, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2833, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2837, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2838, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2839, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2840, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(2844, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(2845, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(2849, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(2853, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(2854, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2855, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2856, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(2857, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2858, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2862, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(2863, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2864, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2865, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(2866, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2867, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2868, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2869, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2870, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2871, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2872, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2873, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2877, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2878, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2879, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2880, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(2881, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2882, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2883, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2884, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2885, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2886, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2887, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2888, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2892, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2893, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2894, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2910, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(2911, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2912, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2913, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2914, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2915, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2916, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2917, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2918, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2922, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2923, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2924, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2928, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2929, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2930, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2931, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2932, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2933, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2937, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2938, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2939, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2940, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2941, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2942, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2943, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2944, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2945, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2946, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2947, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2948, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2952, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2953, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2954, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2955, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2956, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2957, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2958, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2959, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2960, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2961, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2962, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2963, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2967, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2968, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2969, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2985, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2986, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2987, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2988, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2989, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2990, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2991, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2992, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2993, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2997, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2998, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2999, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3003, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3004, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3005, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3006, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3007, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3008, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3012, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3013, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3014, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3015, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3016, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3017, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3018, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3019, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3020, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3021, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3022, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3023, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3027, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3028, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3029, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3030, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3031, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3032, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3033, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3034, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3035, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3036, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3037, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3038, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3042, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3043, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3044, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3060, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3061, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3062, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3063, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3064, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3065, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3066, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3067, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3068, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3072, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3073, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3074, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3078, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3079, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3080, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3081, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3082, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3083, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3087, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3088, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3089, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3090, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3091, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3092, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3093, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3094, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3095, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3096, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3097, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3098, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3102, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3103, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3104, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3105, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3106, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3107, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3108, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3109, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3110, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3111, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3112, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3113, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3117, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3118, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3119, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3135, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3136, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3137, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3138, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3139, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3140, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3141, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3142, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3143, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3147, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3148, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3149, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3150, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3151, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3152, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3153, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3154, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3155, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3156, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3157, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3158, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3159, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3160, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3161, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3162, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3163, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ _(3164, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3165, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(3166, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3167, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3166, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3167, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3168, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ _(3169, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3170, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(3171, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3172, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3171, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3172, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3173, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ _(3174, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3176, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3177, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3176, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3178, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ _(3179, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3180, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3181, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3182, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3181, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3182, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3183, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ _(3184, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3185, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ _(3186, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3187, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3187, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3188, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ _(3189, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3195, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(3196, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3197, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3191, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3197, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3198, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ _(3199, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3202, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3204, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3207, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \ - _(3209, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \ - _(3210, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3211, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3212, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3213, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3213+1, ZEND_NULL) + _(3201, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3204, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3206, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3209, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \ + _(3211, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \ + _(3212, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3213, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3214, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3215, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3215+1, ZEND_NULL) diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index 1d96e1f0938ea..19e299edf907d 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -22,7 +22,7 @@ #include #include -static const char *zend_vm_opcodes_names[195] = { +static const char *zend_vm_opcodes_names[197] = { "ZEND_NOP", "ZEND_ADD", "ZEND_SUB", @@ -218,9 +218,11 @@ static const char *zend_vm_opcodes_names[195] = { "ZEND_GET_CALLED_CLASS", "ZEND_GET_TYPE", "ZEND_ARRAY_KEY_EXISTS", + "ZEND_CALL_DECORATED", + "ZEND_RETURN_DECORATED", }; -static uint32_t zend_vm_opcodes_flags[195] = { +static uint32_t zend_vm_opcodes_flags[197] = { 0x00000000, 0x00000b0b, 0x00000b0b, @@ -416,6 +418,8 @@ static uint32_t zend_vm_opcodes_flags[195] = { 0x00000101, 0x00000103, 0x00000707, + 0x00000000, + 0x00000000, }; ZEND_API const char* ZEND_FASTCALL zend_get_opcode_name(zend_uchar opcode) { diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h index 60bcb66643e8b..4ce18bec1da15 100644 --- a/Zend/zend_vm_opcodes.h +++ b/Zend/zend_vm_opcodes.h @@ -271,7 +271,9 @@ END_EXTERN_C() #define ZEND_GET_CALLED_CLASS 192 #define ZEND_GET_TYPE 193 #define ZEND_ARRAY_KEY_EXISTS 194 +#define ZEND_CALL_DECORATED 195 +#define ZEND_RETURN_DECORATED 196 -#define ZEND_VM_LAST_OPCODE 194 +#define ZEND_VM_LAST_OPCODE 196 #endif diff --git a/ext/tokenizer/tokenizer_data.c b/ext/tokenizer/tokenizer_data.c index 414202ff3b9ab..4f4548f9779b4 100644 --- a/ext/tokenizer/tokenizer_data.c +++ b/ext/tokenizer/tokenizer_data.c @@ -70,7 +70,6 @@ void tokenizer_register_constants(INIT_FUNC_ARGS) { REGISTER_LONG_CONSTANT("T_BOOL_CAST", T_BOOL_CAST, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_UNSET_CAST", T_UNSET_CAST, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_POW", T_POW, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("T_NEW", T_NEW, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_CLONE", T_CLONE, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_ELSEIF", T_ELSEIF, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_ELSE", T_ELSE, CONST_CS | CONST_PERSISTENT); @@ -86,6 +85,7 @@ void tokenizer_register_constants(INIT_FUNC_ARGS) { REGISTER_LONG_CONSTANT("T_EVAL", T_EVAL, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_INC", T_INC, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_DEC", T_DEC, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("T_NEW", T_NEW, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_EXIT", T_EXIT, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_IF", T_IF, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_ENDIF", T_ENDIF, CONST_CS | CONST_PERSISTENT); @@ -98,6 +98,7 @@ void tokenizer_register_constants(INIT_FUNC_ARGS) { REGISTER_LONG_CONSTANT("T_FOREACH", T_FOREACH, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_ENDFOREACH", T_ENDFOREACH, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_DECLARE", T_DECLARE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("T_DECORATED", T_DECORATED, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_ENDDECLARE", T_ENDDECLARE, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_AS", T_AS, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_SWITCH", T_SWITCH, CONST_CS | CONST_PERSISTENT); @@ -213,7 +214,6 @@ char *get_token_type_name(int token_type) case T_BOOL_CAST: return "T_BOOL_CAST"; case T_UNSET_CAST: return "T_UNSET_CAST"; case T_POW: return "T_POW"; - case T_NEW: return "T_NEW"; case T_CLONE: return "T_CLONE"; case T_ELSEIF: return "T_ELSEIF"; case T_ELSE: return "T_ELSE"; @@ -229,6 +229,7 @@ char *get_token_type_name(int token_type) case T_EVAL: return "T_EVAL"; case T_INC: return "T_INC"; case T_DEC: return "T_DEC"; + case T_NEW: return "T_NEW"; case T_EXIT: return "T_EXIT"; case T_IF: return "T_IF"; case T_ENDIF: return "T_ENDIF"; @@ -241,6 +242,7 @@ char *get_token_type_name(int token_type) case T_FOREACH: return "T_FOREACH"; case T_ENDFOREACH: return "T_ENDFOREACH"; case T_DECLARE: return "T_DECLARE"; + case T_DECORATED: return "T_DECORATED"; case T_ENDDECLARE: return "T_ENDDECLARE"; case T_AS: return "T_AS"; case T_SWITCH: return "T_SWITCH";