From a204fc4c40156ee48fb0fa5061896287808c231c Mon Sep 17 00:00:00 2001 From: Pratik Bhujel Date: Wed, 18 Nov 2026 10:00:09 +0545 Subject: [PATCH 1/6] Fix GH-25379: Preserve array_map() semantics in foreach optimization --- Zend/Optimizer/compact_literals.c | 1 + Zend/Optimizer/optimize_func_calls.c | 11 +- ...rray_map_foreach_optimization_gh25379.phpt | 334 ++++ Zend/zend_compile.c | 214 ++- Zend/zend_vm_def.h | 20 +- Zend/zend_vm_execute.h | 1019 +++++++---- Zend/zend_vm_handlers.h | 1507 +++++++++-------- Zend/zend_vm_opcodes.c | 2 +- .../array_map_foreach_optimization_006.phpt | 2 +- .../array_map_foreach_optimization_012.phpt | 6 +- .../array_map_foreach_optimization_014.phpt | 2 +- 11 files changed, 1997 insertions(+), 1121 deletions(-) create mode 100644 Zend/tests/array_map_foreach_optimization_gh25379.phpt diff --git a/Zend/Optimizer/compact_literals.c b/Zend/Optimizer/compact_literals.c index 6ed7e870da61..bc14d03cb671 100644 --- a/Zend/Optimizer/compact_literals.c +++ b/Zend/Optimizer/compact_literals.c @@ -749,6 +749,7 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx case ZEND_SEND_VAR_NO_REF_EX: case ZEND_SEND_REF: case ZEND_SEND_FUNC_ARG: + case ZEND_SEND_USER: case ZEND_SEND_PLACEHOLDER: case ZEND_CHECK_FUNC_ARG: if (opline->op2_type == IS_CONST) { diff --git a/Zend/Optimizer/optimize_func_calls.c b/Zend/Optimizer/optimize_func_calls.c index 4275bdb4071c..129c62230c80 100644 --- a/Zend/Optimizer/optimize_func_calls.c +++ b/Zend/Optimizer/optimize_func_calls.c @@ -356,8 +356,17 @@ void zend_optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx) break; } break; - case ZEND_SEND_UNPACK: case ZEND_SEND_USER: + if (opline->op2_type != IS_CONST + && (opline->op1_type & (IS_CONST|IS_TMP_VAR)) + && has_known_send_mode(&call_stack[call - 1], opline->op2.num) + && !ARG_MUST_BE_SENT_BY_REF(call_stack[call - 1].func, opline->op2.num)) { + opline->opcode = ZEND_SEND_VAL; + break; + } + call_stack[call - 1].try_inline = false; + break; + case ZEND_SEND_UNPACK: case ZEND_SEND_ARRAY: call_stack[call - 1].try_inline = false; break; diff --git a/Zend/tests/array_map_foreach_optimization_gh25379.phpt b/Zend/tests/array_map_foreach_optimization_gh25379.phpt new file mode 100644 index 000000000000..41a75b0233dc --- /dev/null +++ b/Zend/tests/array_map_foreach_optimization_gh25379.phpt @@ -0,0 +1,334 @@ +--TEST-- +GH-25379: array_map() foreach optimization preserves callee evaluation, by-ref warnings, and dynamic call restrictions +--FILE-- +getMessage(), "\n"; + } + + try { + array_map(getf()(...), 5); + } catch (TypeError $e) { + echo $e->getMessage(), "\n"; + } + + try { + array_map(getc()::m(...), "a" . "b"); + } catch (TypeError $e) { + echo $e->getMessage(), "\n"; + } + + try { + array_map(getc()::{(getm())}(...), 5); + } catch (TypeError $e) { + echo $e->getMessage(), "\n"; + } + + try { + array_map(Foo::{(getm())}(...), 5); + } catch (Error $e) { + echo $e->getMessage(), "\n"; + } + + try { + array_map(getc()::{(throw_getm())}(...), 5); + } catch (RuntimeException $e) { + echo $e->getMessage(), "\n"; + } + + try { + var_dump(array_map(getf()(?, ...), [1])); + } catch (Error $e) { + echo $e->getMessage(), "\n"; + } + + try { + var_dump(array_map(getf()(?, ?), [1])); + } catch (Error $e) { + echo $e->getMessage(), "\n"; + } + + try { + var_dump(array_map(getf_named()(a: 1, ...), [2])); + } catch (Error $e) { + echo $e->getMessage(), "\n"; + } + + /* 2. By-ref callbacks emit warning and wrap instead of throwing Error */ + function inc(&$x) { + $x++; + return $x; + } + + function inc2(&$x, $n) { + $x += $n; + return $x; + } + + function var_ref(&...$a) { + return $a; + } + + class ByRef { + public static function m(&$x) { + $x++; + return $x; + } + } + + var_dump(array_map(inc(...), [1])); + var_dump(array_map(sort(...), [[3, 1]])); + var_dump(array_map(inc2(?, 2), [1])); + var_dump(array_map(var_ref(...), [1])); + var_dump(array_map(ByRef::m(...), [1])); + var_dump(array_map(inc2(n: 3, x: ?), [1])); + + class ByRefChild extends ByRef { + public static function viaStatic() { + return array_map(static::m(...), [1]); + } + public static function viaParent() { + return array_map(parent::m(...), [1]); + } + public static function viaSelf() { + return array_map(self::m(...), [1]); + } + } + + function rec(&$x) { + static $depth = 0; + if ($depth++) { + return ++$x; + } + return array_map(rec(...), [1]); + } + + var_dump(array_map(later(...), [1])); + $f = 'sort'; + var_dump(array_map($f(...), [[3, 1]])); + var_dump(ByRefChild::viaStatic()); + var_dump(ByRefChild::viaParent()); + var_dump(ByRefChild::viaSelf()); + $v = 1; + var_dump(rec($v)); + var_dump(array_map(later2(n: 3, x: ?), [1])); + + function later(&$x) { + return ++$x; + } + + function later2(&$x, $n) { + $x += $n; + return $x; + } + + /* 3. Dynamic-call-forbidden functions throw Error instead of reading caller scope */ + function test_forbid_dyn($a, $b) { + try { + array_map(extract(...), [['zz' => 1]]); + } catch (Error $e) { + echo $e->getMessage(), "\n"; + } + var_dump($zz ?? 'unset'); + + $x = 5; + try { + array_map(compact(...), ['x']); + } catch (Error $e) { + echo $e->getMessage(), "\n"; + } + try { + array_map(func_get_arg(...), [0]); + } catch (Error $e) { + echo $e->getMessage(), "\n"; + } + try { + array_map(func_get_args(...), [[]]); + } catch (Error $e) { + echo $e->getMessage(), "\n"; + } + try { + array_map(func_num_args(...), [[]]); + } catch (Error $e) { + echo $e->getMessage(), "\n"; + } + try { + array_map(get_defined_vars(...), [[]]); + } catch (Error $e) { + echo $e->getMessage(), "\n"; + } + } + test_forbid_dyn('A', 'B'); +} + +namespace NsTest { + function test_ns() { + \var_dump(\array_map(sort(...), [[3, 1]])); + try { + \array_map(extract(...), [['zz' => 1]]); + } catch (\Error $e) { + echo $e->getMessage(), "\n"; + } + } + test_ns(); +} + +?> +--EXPECTF-- +getf +array_map(): Argument #2 ($array) must be of type array, int given +getf +array_map(): Argument #2 ($array) must be of type array, int given +getc +array_map(): Argument #2 ($array) must be of type array, string given +getc +getm +array_map(): Argument #2 ($array) must be of type array, int given +getm +Class "Foo" not found +getc +boom m +getf +array(1) { + [0]=> + string(1) "1" +} +getf +Partial application of strtoupper() expects at most 1 arguments, 2 given +getf_named +array(1) { + [0]=> + int(3) +} + +Warning: inc(): Argument #1 ($x) must be passed by reference, value given in %s on line %d +array(1) { + [0]=> + int(2) +} + +Warning: sort(): Argument #1 ($array) must be passed by reference, value given in %s on line %d +array(1) { + [0]=> + bool(true) +} + +Warning: inc2(): Argument #1 ($x) must be passed by reference, value given in %s on line %d +array(1) { + [0]=> + int(3) +} + +Warning: var_ref(): Argument #1 must be passed by reference, value given in %s on line %d +array(1) { + [0]=> + array(1) { + [0]=> + int(1) + } +} + +Warning: ByRef::m(): Argument #1 ($x) must be passed by reference, value given in %s on line %d +array(1) { + [0]=> + int(2) +} + +Warning: inc2(): Argument #1 ($x) must be passed by reference, value given in %s on line %d +array(1) { + [0]=> + int(4) +} + +Warning: later(): Argument #1 ($x) must be passed by reference, value given in %s on line %d +array(1) { + [0]=> + int(2) +} + +Warning: sort(): Argument #1 ($array) must be passed by reference, value given in %s on line %d +array(1) { + [0]=> + bool(true) +} + +Warning: ByRef::m(): Argument #1 ($x) must be passed by reference, value given in %s on line %d +array(1) { + [0]=> + int(2) +} + +Warning: ByRef::m(): Argument #1 ($x) must be passed by reference, value given in %s on line %d +array(1) { + [0]=> + int(2) +} + +Warning: ByRef::m(): Argument #1 ($x) must be passed by reference, value given in %s on line %d +array(1) { + [0]=> + int(2) +} + +Warning: rec(): Argument #1 ($x) must be passed by reference, value given in %s on line %d +array(1) { + [0]=> + int(2) +} + +Warning: later2(): Argument #1 ($x) must be passed by reference, value given in %s on line %d +array(1) { + [0]=> + int(4) +} +Cannot call extract() dynamically +string(5) "unset" +Cannot call compact() dynamically +Cannot call func_get_arg() dynamically +func_get_args() expects exactly 0 arguments, 1 given +func_num_args() expects exactly 0 arguments, 1 given +get_defined_vars() expects exactly 0 arguments, 1 given + +Warning: sort(): Argument #1 ($array) must be passed by reference, value given in %s on line %d +array(1) { + [0]=> + bool(true) +} +Cannot call extract() dynamically diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index abed76366229..ba40acf516d2 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -105,7 +105,9 @@ static void zend_compile_expr(znode *result, zend_ast *ast); static void zend_compile_stmt(zend_ast *ast); static void zend_compile_assign(znode *result, zend_ast *ast, bool stmt, uint32_t type); +static bool zend_is_pipe_optimizable_callable_name(zend_ast *ast); static zend_ast *zend_partial_apply(zend_ast *callable_ast, zend_ast *pipe_arg); +static const zend_function *zend_get_compatible_func_or_null(const zend_class_entry *ce, zend_string *lcname); #ifdef ZEND_CHECK_STACK_LIMIT zend_never_inline static void zend_stack_limit_error(void) @@ -5330,7 +5332,29 @@ static zend_result zend_compile_func_clone(znode *result, const zend_ast_list *a return SUCCESS; } -static zend_result zend_compile_func_array_map(znode *result, zend_ast_list *args, zend_string *lcname, uint32_t lineno) /* {{{ */ +static const zend_class_entry *zend_resolve_compile_time_parent(const zend_class_entry *ce) /* {{{ */ +{ + if (ce->ce_flags & ZEND_ACC_LINKED) { + return ce->parent; + } + if (!ce->parent_name) { + return NULL; + } + + zend_string *parent_lcname = zend_string_tolower(ce->parent_name); + const zend_class_entry *parent_ce = zend_hash_find_ptr(CG(class_table), parent_lcname); + zend_string_release_ex(parent_lcname, 0); + if (!parent_ce + || parent_ce == ce + || zend_compile_ignore_class(parent_ce, CG(active_op_array)->filename)) { + return NULL; + } + + return parent_ce; +} +/* }}} */ + +static zend_result zend_compile_func_array_map(znode *result, zend_ast_list *args, zend_string *lcname, uint32_t lineno, uint32_t type) /* {{{ */ { /* array_map() as an internal function calls the callback as if strict_types=0, * this optimization is therefore not legal if strict_types=1. */ @@ -5354,18 +5378,34 @@ static zend_result zend_compile_func_array_map(znode *result, zend_ast_list *arg return FAILURE; } + if (callback->kind == ZEND_AST_CALL + && !zend_is_pipe_optimizable_callable_name(callback->child[0])) { + return FAILURE; + } + /* PFAs with non-literal pre-bound arguments are not optimizable because we * can't memoize arguments without breaking pass-by-reference. - * TODO: Support PFAs when the function is known to not receive by ref. */ + * Also reject cases that zend_partial_apply() will refuse before emitting + * any bytecode for the callee expression. */ zend_ast_fcc *fcc = (zend_ast_fcc*)args_ast; zend_ast_list *fcc_args = zend_ast_get_list(fcc->args); + bool uses_named_args = false; + bool has_placeholder = false; for (uint32_t i = 0; i < fcc_args->children; i++) { zend_ast *arg = fcc_args->child[i]; if (arg->kind == ZEND_AST_NAMED_ARG) { + uses_named_args = true; arg = arg->child[1]; } if (arg->kind == ZEND_AST_PLACEHOLDER_ARG) { + if (has_placeholder) { + return FAILURE; + } + if (arg->attr == ZEND_PLACEHOLDER_VARIADIC && uses_named_args) { + return FAILURE; + } + has_placeholder = true; continue; } @@ -5374,6 +5414,44 @@ static zend_result zend_compile_func_array_map(znode *result, zend_ast_list *arg } } + if (!has_placeholder) { + return FAILURE; + } + + zend_ast *func_name_ast = callback->child[callback->kind == ZEND_AST_CALL ? 0 : 1]; + if (callback->kind == ZEND_AST_CALL + && func_name_ast->kind == ZEND_AST_ZVAL + && Z_TYPE_P(zend_ast_get_zval(func_name_ast)) == IS_STRING) { + bool is_fully_qualified; + zend_string *resolved_name = zend_resolve_function_name( + zend_ast_get_str(func_name_ast), func_name_ast->attr, &is_fully_qualified); + zend_string *callee_lcname = zend_string_tolower(resolved_name); + const zend_function *callee_fbc = zend_hash_find_ptr(CG(function_table), callee_lcname); + zend_string_release_ex(resolved_name, 0); + zend_string_release_ex(callee_lcname, 0); + + if (callee_fbc + && (!fbc_is_finalized(callee_fbc) + || zend_compile_ignore_function(callee_fbc, CG(active_op_array)->filename))) { + callee_fbc = NULL; + } + if (callee_fbc && (callee_fbc->common.fn_flags2 & ZEND_ACC2_FORBID_DYN_CALLS)) { + return FAILURE; + } + if (!callee_fbc && !is_fully_qualified && FC(current_namespace)) { + /* Unqualified calls in a namespace fall back to the global function at runtime. */ + zend_string *global_lcname = zend_string_tolower(zend_ast_get_str(func_name_ast)); + callee_fbc = zend_hash_find_ptr(CG(function_table), global_lcname); + zend_string_release_ex(global_lcname, 0); + if (callee_fbc + && fbc_is_finalized(callee_fbc) + && !zend_compile_ignore_function(callee_fbc, CG(active_op_array)->filename) + && (callee_fbc->common.fn_flags2 & ZEND_ACC2_FORBID_DYN_CALLS)) { + return FAILURE; + } + } + } + /* Evaluate class name */ znode class_node; if (callback->kind == ZEND_AST_STATIC_CALL @@ -5399,7 +5477,6 @@ static zend_result zend_compile_func_array_map(znode *result, zend_ast_list *arg /* Evaluate function name */ znode func_node; - zend_ast *func_name_ast = callback->child[callback->kind == ZEND_AST_CALL ? 0 : 1]; if (callback->kind == ZEND_AST_CALL && func_name_ast->kind == ZEND_AST_ZVAL && Z_TYPE_P(zend_ast_get_zval(func_name_ast)) == IS_STRING) { @@ -5419,14 +5496,43 @@ static zend_result zend_compile_func_array_map(znode *result, zend_ast_list *arg } } - znode value; - value.op_type = IS_TMP_VAR; - value.u.op.var = get_temporary_variable(); - - zend_ast *call_args = zend_partial_apply(callback, - zend_ast_create_znode(&value)); - if (!call_args) { - goto fail; + if (class_node.op_type == IS_CONST + && func_node.op_type == IS_CONST + && Z_TYPE(func_node.u.constant) == IS_STRING) { + const zend_class_entry *ce = NULL; + uint32_t fetch_type = zend_get_class_fetch_type(Z_STR(class_node.u.constant)); + if (fetch_type == ZEND_FETCH_CLASS_DEFAULT) { + zend_string *ce_lcname = zend_string_tolower(Z_STR(class_node.u.constant)); + ce = zend_hash_find_ptr(CG(class_table), ce_lcname); + zend_string_release_ex(ce_lcname, 0); + if (ce) { + if (zend_compile_ignore_class(ce, CG(active_op_array)->filename)) { + ce = NULL; + } + } else if (CG(active_class_entry) + && zend_string_equals_ci(CG(active_class_entry)->name, Z_STR(class_node.u.constant))) { + ce = CG(active_class_entry); + } + } else if (fetch_type == ZEND_FETCH_CLASS_SELF && zend_is_scope_known()) { + ce = CG(active_class_entry); + } else if (fetch_type == ZEND_FETCH_CLASS_PARENT && zend_is_scope_known()) { + ce = zend_resolve_compile_time_parent(CG(active_class_entry)); + } + if (ce) { + zend_string *method_lcname = zend_string_tolower(Z_STR(func_node.u.constant)); + const zend_function *callee_fbc = NULL; + for (const zend_class_entry *cur_ce = ce; cur_ce && !callee_fbc; cur_ce = zend_resolve_compile_time_parent(cur_ce)) { + if (!zend_compile_ignore_class(cur_ce, CG(active_op_array)->filename)) { + callee_fbc = zend_get_compatible_func_or_null(cur_ce, method_lcname); + } + } + zend_string_release_ex(method_lcname, 0); + if (callee_fbc && (callee_fbc->common.fn_flags2 & ZEND_ACC2_FORBID_DYN_CALLS)) { + zval_ptr_dtor_nogc(&func_node.u.constant); + zval_ptr_dtor_nogc(&class_node.u.constant); + return FAILURE; + } + } } zend_op *opline; @@ -5436,12 +5542,68 @@ static zend_result zend_compile_func_array_map(znode *result, zend_ast_list *arg /* array is an argument to both ZEND_TYPE_ASSERT and to ZEND_FE_RESET_R. */ if (array.op_type == IS_CONST) { if (Z_TYPE(array.u.constant) != IS_ARRAY) { - zval_ptr_dtor_nogc(&array.u.constant); - goto fail; + if (class_node.op_type != IS_TMP_VAR && func_node.op_type != IS_TMP_VAR) { + zval_ptr_dtor_nogc(&array.u.constant); + if (func_node.op_type == IS_CONST) { + zval_ptr_dtor_nogc(&func_node.u.constant); + } + if (class_node.op_type == IS_CONST) { + zval_ptr_dtor_nogc(&class_node.u.constant); + } + return FAILURE; + } + + /* Callee subexpressions already emitted runtime opcodes into TMP_VARs; + * fall back to a regular array_map() call reusing them so nothing is + * evaluated twice or leaked. */ + zend_ast *func_ast = func_node.op_type == IS_UNUSED + ? func_name_ast + : zend_ast_create_znode(&func_node); + zend_ast *cb_ast; + if (callback->kind == ZEND_AST_CALL) { + cb_ast = zend_ast_create(ZEND_AST_CALL, func_ast, args_ast); + } else { + zend_ast *class_ast; + if (class_node.op_type == IS_CONST) { + zval_ptr_dtor_nogc(&class_node.u.constant); + class_ast = callback->child[0]; + } else { + class_ast = zend_ast_create_znode(&class_node); + } + cb_ast = zend_ast_create(ZEND_AST_STATIC_CALL, class_ast, func_ast, args_ast); + } + cb_ast->lineno = callback->lineno; + + znode fcall_name; + fcall_name.op_type = IS_CONST; + ZVAL_STR_COPY(&fcall_name.u.constant, lcname); + opline = zend_emit_op(NULL, ZEND_INIT_FCALL, NULL, &fcall_name); + opline->lineno = lineno; + opline->result.num = zend_alloc_cache_slot(); + + const zval *fbc_zv = zend_hash_find(CG(function_table), lcname); + const zend_function *array_map_fbc = Z_PTR_P(fbc_zv); + if (array_map_fbc->type == ZEND_INTERNAL_FUNCTION) { + const Bucket *fbc_bucket = ZEND_CONTAINER_OF(fbc_zv, Bucket, val); + Z_EXTRA_P(CT_CONSTANT(opline->op2)) = fbc_bucket - CG(function_table)->arData; + } + + zend_ast *fallback_args = zend_ast_create_list(2, ZEND_AST_ARG_LIST, + cb_ast, zend_ast_create_znode(&array)); + zend_compile_call_common(result, fallback_args, array_map_fbc, lineno, type); + return SUCCESS; } Z_TRY_ADDREF(array.u.constant); } + znode value; + value.op_type = IS_TMP_VAR; + value.u.op.var = get_temporary_variable(); + + zend_ast *call_args = zend_partial_apply(callback, + zend_ast_create_znode(&value)); + ZEND_ASSERT(call_args); + /* Verify that the input array actually is an array. */ znode name; name.op_type = IS_CONST; @@ -5478,6 +5640,7 @@ static zend_result zend_compile_func_array_map(znode *result, zend_ast_list *arg zend_emit_op_tmp(©_node, ZEND_COPY_TMP, &func_node, NULL); func_ast = zend_ast_create_znode(©_node); } + uint32_t opnum_call_start = get_next_op_number(); switch (callback->kind) { case ZEND_AST_CALL: { zend_compile_expr(&call_result, zend_ast_create(ZEND_AST_CALL, func_ast, call_args)); @@ -5498,6 +5661,18 @@ static zend_result zend_compile_func_array_map(znode *result, zend_ast_list *arg break; } } + /* Pass the element with ZEND_SEND_USER semantics when the callee's send mode + * is not statically known by-value, so by-ref parameters warn and wrap instead + * of throwing Error. */ + for (uint32_t i = opnum_call_start; i < get_next_op_number(); i++) { + zend_op *op = &CG(active_op_array)->opcodes[i]; + if (op->opcode == ZEND_SEND_VAL_EX + && op->op1_type == IS_TMP_VAR + && op->op1.var == value.u.op.var) { + op->opcode = ZEND_SEND_USER; + break; + } + } if (func_ast != func_name_ast) { zend_ast_destroy(func_ast); } @@ -5523,17 +5698,6 @@ static zend_result zend_compile_func_array_map(znode *result, zend_ast_list *arg } return SUCCESS; - -fail: - CG(active_op_array)->T--; - if (func_node.op_type == IS_CONST) { - zval_ptr_dtor_nogc(&func_node.u.constant); - } - if (class_node.op_type == IS_CONST) { - zval_ptr_dtor_nogc(&class_node.u.constant); - } - - return FAILURE; } static zend_result zend_try_compile_special_func_ex(znode *result, zend_string *lcname, zend_ast_list *args, uint32_t type, uint32_t lineno) /* {{{ */ @@ -5602,7 +5766,7 @@ static zend_result zend_try_compile_special_func_ex(znode *result, zend_string * } else if (zend_string_equals(lcname, ZSTR_KNOWN(ZEND_STR_CLONE))) { return zend_compile_func_clone(result, args); } else if (zend_string_equals_literal(lcname, "array_map")) { - return zend_compile_func_array_map(result, args, lcname, lineno); + return zend_compile_func_array_map(result, args, lcname, lineno, type); } else { return FAILURE; } diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index d10c891a730f..9e9cc00b6a59 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -5670,17 +5670,29 @@ ZEND_VM_C_LABEL(send_array): ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -ZEND_VM_HANDLER(120, ZEND_SEND_USER, CONST|TMP|CV, NUM) +ZEND_VM_HANDLER(120, ZEND_SEND_USER, CONST|TMP|CV, CONST|UNUSED|NUM) { USE_OPLINE zval *arg, *param; + uint32_t arg_num; SAVE_OPLINE(); + if (OP2_TYPE == IS_CONST) { + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!param)) { + FREE_OP1(); + HANDLE_EXCEPTION(); + } + } else { + param = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + arg = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R); - param = ZEND_CALL_VAR(EX(call), opline->result.var); - if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { - zend_param_must_be_ref(EX(call)->func, opline->op2.num); + if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { + zend_param_must_be_ref(EX(call)->func, arg_num); Z_TRY_ADDREF_P(arg); ZVAL_NEW_REF(param, arg); } else { diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 8679330b2d0a..94b1060d8d9a 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -5237,27 +5237,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CATCH_SPEC_CO ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_USER_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *arg, *param; - - SAVE_OPLINE(); - - arg = RT_CONSTANT(opline, opline->op1); - param = ZEND_CALL_VAR(EX(call), opline->result.var); - if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { - zend_param_must_be_ref(EX(call)->func, opline->op2.num); - Z_TRY_ADDREF_P(arg); - ZVAL_NEW_REF(param, arg); - } else { - ZVAL_COPY(param, arg); - } - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -7819,6 +7798,40 @@ send_val_by_ref:; ZEND_VM_NEXT_OPCODE(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_USER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *arg, *param; + uint32_t arg_num; + + SAVE_OPLINE(); + + if (IS_CONST == IS_CONST) { + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!param)) { + + + HANDLE_EXCEPTION(); + } + } else { + param = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + arg = RT_CONSTANT(opline, opline->op1); + if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { + zend_param_must_be_ref(EX(call)->func, arg_num); + Z_TRY_ADDREF_P(arg); + ZVAL_NEW_REF(param, arg); + } else { + ZVAL_COPY(param, arg); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { zend_class_entry *ce, *scope; @@ -11421,6 +11434,40 @@ send_val_by_ref:; ZEND_VM_NEXT_OPCODE(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_USER_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *arg, *param; + uint32_t arg_num; + + SAVE_OPLINE(); + + if (IS_UNUSED == IS_CONST) { + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!param)) { + + + HANDLE_EXCEPTION(); + } + } else { + param = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + arg = RT_CONSTANT(opline, opline->op1); + if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { + zend_param_must_be_ref(EX(call)->func, arg_num); + Z_TRY_ADDREF_P(arg); + ZVAL_NEW_REF(param, arg); + } else { + ZVAL_COPY(param, arg); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -17441,27 +17488,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_THROW_SPEC_TM HANDLE_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *arg, *param; - - SAVE_OPLINE(); - - arg = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - param = ZEND_CALL_VAR(EX(call), opline->result.var); - if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { - zend_param_must_be_ref(EX(call)->func, opline->op2.num); - Z_TRY_ADDREF_P(arg); - ZVAL_NEW_REF(param, arg); - } else { - ZVAL_COPY(param, arg); - } - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_BOOL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -19401,6 +19427,39 @@ send_val_by_ref:; ZEND_VM_NEXT_OPCODE(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_USER_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *arg, *param; + uint32_t arg_num; + + SAVE_OPLINE(); + + if (IS_CONST == IS_CONST) { + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!param)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } else { + param = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + arg = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { + zend_param_must_be_ref(EX(call)->func, arg_num); + Z_TRY_ADDREF_P(arg); + ZVAL_NEW_REF(param, arg); + } else { + ZVAL_COPY(param, arg); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CASE_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -21755,6 +21814,39 @@ send_val_by_ref:; ZEND_VM_NEXT_OPCODE(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_USER_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *arg, *param; + uint32_t arg_num; + + SAVE_OPLINE(); + + if (IS_UNUSED == IS_CONST) { + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!param)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } else { + param = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + arg = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { + zend_param_must_be_ref(EX(call)->func, arg_num); + Z_TRY_ADDREF_P(arg); + ZVAL_NEW_REF(param, arg); + } else { + ZVAL_COPY(param, arg); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -40222,27 +40314,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_THROW_SPEC_CV HANDLE_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *arg, *param; - - SAVE_OPLINE(); - - arg = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); - param = ZEND_CALL_VAR(EX(call), opline->result.var); - if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { - zend_param_must_be_ref(EX(call)->func, opline->op2.num); - Z_TRY_ADDREF_P(arg); - ZVAL_NEW_REF(param, arg); - } else { - ZVAL_COPY(param, arg); - } - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -44274,6 +44345,40 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_VAR_EX_S ZEND_VM_NEXT_OPCODE(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_USER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *arg, *param; + uint32_t arg_num; + + SAVE_OPLINE(); + + if (IS_CONST == IS_CONST) { + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!param)) { + + + HANDLE_EXCEPTION(); + } + } else { + param = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + arg = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); + if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { + zend_param_must_be_ref(EX(call)->func, arg_num); + Z_TRY_ADDREF_P(arg); + ZVAL_NEW_REF(param, arg); + } else { + ZVAL_COPY(param, arg); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -49645,6 +49750,40 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_S ZEND_VM_NEXT_OPCODE(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_USER_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *arg, *param; + uint32_t arg_num; + + SAVE_OPLINE(); + + if (IS_UNUSED == IS_CONST) { + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!param)) { + + + HANDLE_EXCEPTION(); + } + } else { + param = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + arg = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); + if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { + zend_param_must_be_ref(EX(call)->func, arg_num); + Z_TRY_ADDREF_P(arg); + ZVAL_NEW_REF(param, arg); + } else { + ZVAL_COPY(param, arg); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -58132,27 +58271,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CATCH_SPEC_CONST_T ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_USER_SPEC_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *arg, *param; - - SAVE_OPLINE(); - - arg = RT_CONSTANT(opline, opline->op1); - param = ZEND_CALL_VAR(EX(call), opline->result.var); - if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { - zend_param_must_be_ref(EX(call)->func, opline->op2.num); - Z_TRY_ADDREF_P(arg); - ZVAL_NEW_REF(param, arg); - } else { - ZVAL_COPY(param, arg); - } - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_BOOL_SPEC_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -60714,6 +60832,40 @@ send_val_by_ref:; ZEND_VM_NEXT_OPCODE(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_USER_SPEC_CONST_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *arg, *param; + uint32_t arg_num; + + SAVE_OPLINE(); + + if (IS_CONST == IS_CONST) { + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!param)) { + + + HANDLE_EXCEPTION(); + } + } else { + param = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + arg = RT_CONSTANT(opline, opline->op1); + if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { + zend_param_must_be_ref(EX(call)->func, arg_num); + Z_TRY_ADDREF_P(arg); + ZVAL_NEW_REF(param, arg); + } else { + ZVAL_COPY(param, arg); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { zend_class_entry *ce, *scope; @@ -64214,6 +64366,40 @@ send_val_by_ref:; ZEND_VM_NEXT_OPCODE(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_USER_SPEC_CONST_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *arg, *param; + uint32_t arg_num; + + SAVE_OPLINE(); + + if (IS_UNUSED == IS_CONST) { + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!param)) { + + + HANDLE_EXCEPTION(); + } + } else { + param = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + arg = RT_CONSTANT(opline, opline->op1); + if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { + zend_param_must_be_ref(EX(call)->func, arg_num); + Z_TRY_ADDREF_P(arg); + ZVAL_NEW_REF(param, arg); + } else { + ZVAL_COPY(param, arg); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_NEW_SPEC_CONST_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -70234,27 +70420,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_THROW_SPEC_TMP_TAI HANDLE_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_USER_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *arg, *param; - - SAVE_OPLINE(); - - arg = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - param = ZEND_CALL_VAR(EX(call), opline->result.var); - if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { - zend_param_must_be_ref(EX(call)->func, opline->op2.num); - Z_TRY_ADDREF_P(arg); - ZVAL_NEW_REF(param, arg); - } else { - ZVAL_COPY(param, arg); - } - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_BOOL_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -72194,6 +72359,39 @@ send_val_by_ref:; ZEND_VM_NEXT_OPCODE(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_USER_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *arg, *param; + uint32_t arg_num; + + SAVE_OPLINE(); + + if (IS_CONST == IS_CONST) { + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!param)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } else { + param = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + arg = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { + zend_param_must_be_ref(EX(call)->func, arg_num); + Z_TRY_ADDREF_P(arg); + ZVAL_NEW_REF(param, arg); + } else { + ZVAL_COPY(param, arg); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CASE_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -74448,6 +74646,39 @@ send_val_by_ref:; ZEND_VM_NEXT_OPCODE(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_USER_SPEC_TMP_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *arg, *param; + uint32_t arg_num; + + SAVE_OPLINE(); + + if (IS_UNUSED == IS_CONST) { + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!param)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } else { + param = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + arg = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { + zend_param_must_be_ref(EX(call)->func, arg_num); + Z_TRY_ADDREF_P(arg); + ZVAL_NEW_REF(param, arg); + } else { + ZVAL_COPY(param, arg); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -92915,27 +93146,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_THROW_SPEC_CV_TAIL HANDLE_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_USER_SPEC_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *arg, *param; - - SAVE_OPLINE(); - - arg = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); - param = ZEND_CALL_VAR(EX(call), opline->result.var); - if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { - zend_param_must_be_ref(EX(call)->func, opline->op2.num); - Z_TRY_ADDREF_P(arg); - ZVAL_NEW_REF(param, arg); - } else { - ZVAL_COPY(param, arg); - } - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_BOOL_SPEC_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -96967,6 +97177,40 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_VAR_EX_SPEC_C ZEND_VM_NEXT_OPCODE(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_USER_SPEC_CV_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *arg, *param; + uint32_t arg_num; + + SAVE_OPLINE(); + + if (IS_CONST == IS_CONST) { + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!param)) { + + + HANDLE_EXCEPTION(); + } + } else { + param = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + arg = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); + if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { + zend_param_must_be_ref(EX(call)->func, arg_num); + Z_TRY_ADDREF_P(arg); + ZVAL_NEW_REF(param, arg); + } else { + ZVAL_COPY(param, arg); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -102236,6 +102480,40 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_V ZEND_VM_NEXT_OPCODE(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_USER_SPEC_CV_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *arg, *param; + uint32_t arg_num; + + SAVE_OPLINE(); + + if (IS_UNUSED == IS_CONST) { + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!param)) { + + + HANDLE_EXCEPTION(); + } + } else { + param = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + arg = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); + if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { + zend_param_must_be_ref(EX(call)->func, arg_num); + Z_TRY_ADDREF_P(arg); + ZVAL_NEW_REF(param, arg); + } else { + ZVAL_COPY(param, arg); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -109282,11 +109560,31 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CV_LABEL, (void*)&&ZEND_SEND_ARRAY_SPEC_LABEL, - (void*)&&ZEND_SEND_USER_SPEC_CONST_LABEL, - (void*)&&ZEND_SEND_USER_SPEC_TMP_LABEL, + (void*)&&ZEND_SEND_USER_SPEC_CONST_CONST_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_USER_SPEC_CONST_UNUSED_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_USER_SPEC_TMP_CONST_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_USER_SPEC_TMP_UNUSED_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_USER_SPEC_CV_CONST_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_USER_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_SEND_USER_SPEC_CV_LABEL, (void*)&&ZEND_STRLEN_SPEC_CONST_LABEL, (void*)&&ZEND_STRLEN_SPEC_TMP_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -111361,11 +111659,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_CATCH_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_CATCH_SPEC_CONST) HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_USER_SPEC_CONST): - VM_TRACE(ZEND_SEND_USER_SPEC_CONST) - ZEND_SEND_USER_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_CONST) - HYBRID_BREAK(); HYBRID_CASE(ZEND_BOOL_SPEC_CONST): VM_TRACE(ZEND_BOOL_SPEC_CONST) ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -111641,6 +111934,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_CONST_CONST) HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_USER_SPEC_CONST_CONST): + VM_TRACE(ZEND_SEND_USER_SPEC_CONST_CONST) + ZEND_SEND_USER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_CONST_CONST) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST): VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -112021,6 +112319,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK) HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_USER_SPEC_CONST_UNUSED): + VM_TRACE(ZEND_SEND_USER_SPEC_CONST_UNUSED) + ZEND_SEND_USER_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_CONST_UNUSED) + HYBRID_BREAK(); HYBRID_CASE(ZEND_NEW_SPEC_CONST_UNUSED): VM_TRACE(ZEND_NEW_SPEC_CONST_UNUSED) ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -112985,11 +113288,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_THROW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_THROW_SPEC_TMP) HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_USER_SPEC_TMP): - VM_TRACE(ZEND_SEND_USER_SPEC_TMP) - ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_TMP) - HYBRID_BREAK(); HYBRID_CASE(ZEND_BOOL_SPEC_TMP): VM_TRACE(ZEND_BOOL_SPEC_TMP) ZEND_BOOL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -113175,6 +113473,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_TMP_CONST) HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_USER_SPEC_TMP_CONST): + VM_TRACE(ZEND_SEND_USER_SPEC_TMP_CONST) + ZEND_SEND_USER_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_TMP_CONST) + HYBRID_BREAK(); HYBRID_CASE(ZEND_CASE_SPEC_TMP_CONST): VM_TRACE(ZEND_CASE_SPEC_TMP_CONST) ZEND_CASE_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -113410,6 +113713,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK) HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_USER_SPEC_TMP_UNUSED): + VM_TRACE(ZEND_SEND_USER_SPEC_TMP_UNUSED) + ZEND_SEND_USER_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_TMP_UNUSED) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED) ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -114874,11 +115182,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_THROW_SPEC_CV) HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_USER_SPEC_CV): - VM_TRACE(ZEND_SEND_USER_SPEC_CV) - ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_CV) - HYBRID_BREAK(); HYBRID_CASE(ZEND_BOOL_SPEC_CV): VM_TRACE(ZEND_BOOL_SPEC_CV) ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -115249,6 +115552,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_CV_CONST) HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_USER_SPEC_CV_CONST): + VM_TRACE(ZEND_SEND_USER_SPEC_CV_CONST) + ZEND_SEND_USER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_CV_CONST) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST) ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -115674,6 +115982,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK) HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_USER_SPEC_CV_UNUSED): + VM_TRACE(ZEND_SEND_USER_SPEC_CV_UNUSED) + ZEND_SEND_USER_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_CV_UNUSED) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED) ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -118250,11 +118563,31 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER, ZEND_SEND_ARRAY_SPEC_HANDLER, - ZEND_SEND_USER_SPEC_CONST_HANDLER, - ZEND_SEND_USER_SPEC_TMP_HANDLER, + ZEND_SEND_USER_SPEC_CONST_CONST_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_SEND_USER_SPEC_CONST_UNUSED_HANDLER, + ZEND_NULL_HANDLER, + ZEND_SEND_USER_SPEC_TMP_CONST_HANDLER, + ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, + ZEND_SEND_USER_SPEC_TMP_UNUSED_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_SEND_USER_SPEC_CV_CONST_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_SEND_USER_SPEC_CV_UNUSED_HANDLER, ZEND_NULL_HANDLER, - ZEND_SEND_USER_SPEC_CV_HANDLER, ZEND_STRLEN_SPEC_CONST_HANDLER, ZEND_STRLEN_SPEC_TMP_HANDLER, ZEND_NULL_HANDLER, @@ -121738,11 +122071,31 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_INIT_USER_CALL_SPEC_CONST_CV_TAILCALL_HANDLER, ZEND_SEND_ARRAY_SPEC_TAILCALL_HANDLER, - ZEND_SEND_USER_SPEC_CONST_TAILCALL_HANDLER, - ZEND_SEND_USER_SPEC_TMP_TAILCALL_HANDLER, + ZEND_SEND_USER_SPEC_CONST_CONST_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_SEND_USER_SPEC_CONST_UNUSED_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_SEND_USER_SPEC_TMP_CONST_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_SEND_USER_SPEC_TMP_UNUSED_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_SEND_USER_SPEC_CV_CONST_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_SEND_USER_SPEC_CV_UNUSED_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, - ZEND_SEND_USER_SPEC_CV_TAILCALL_HANDLER, ZEND_STRLEN_SPEC_CONST_TAILCALL_HANDLER, ZEND_STRLEN_SPEC_TMP_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -123122,7 +123475,7 @@ void zend_vm_init(void) 1255, 1256 | SPEC_RULE_OP1, 1261 | SPEC_RULE_OP1, - 3484, + 3504, 1266 | SPEC_RULE_OP1, 1271 | SPEC_RULE_OP1, 1276 | SPEC_RULE_OP2, @@ -123156,7 +123509,7 @@ void zend_vm_init(void) 1559 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 1584 | SPEC_RULE_OP1, 1589, - 3484, + 3504, 1590 | SPEC_RULE_OP1, 1595 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 1620 | SPEC_RULE_OP1 | SPEC_RULE_OP2, @@ -123197,142 +123550,142 @@ void zend_vm_init(void) 2122 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 2147 | SPEC_RULE_OP2, 2152, - 2153 | SPEC_RULE_OP1, - 2158 | SPEC_RULE_OP1, - 2163, - 2164 | SPEC_RULE_OP1, - 2169 | SPEC_RULE_OP1, - 2174 | SPEC_RULE_OP1, - 2179, - 2180, - 2181 | SPEC_RULE_OP2, - 2186 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, - 2190 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, - 2194 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, - 2198 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2198 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2223 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2223 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2248 | SPEC_RULE_OP1, - 2253, - 2254 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2279, - 2280 | SPEC_RULE_OP1, - 2285, - 2286, - 2287, - 2288, - 2289, - 2290, - 2291, - 2292 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2317, - 2318, - 2319, - 2320 | SPEC_RULE_OP1, - 2325, - 2326 | SPEC_RULE_ISSET, - 2328 | SPEC_RULE_OP2, - 2333, - 2334 | SPEC_RULE_OP1, - 2339 | SPEC_RULE_OBSERVER, - 2341, - 2342 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2367 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, - 2377, - 2378, - 2379, - 2380, - 2381 | SPEC_RULE_OP1, - 2386, - 2387, - 2388 | SPEC_RULE_OP1, - 2393 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2418, - 2419 | SPEC_RULE_OP1, - 2424, - 2425, - 2426, - 2427, - 2428, - 2429, - 2430, - 2431, - 2432 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2457, - 2458, - 2459, - 2460 | SPEC_RULE_OP2, - 2465, - 2466 | SPEC_RULE_OP1, - 2471 | SPEC_RULE_OP1, - 2476 | SPEC_RULE_OP1, - 2481 | SPEC_RULE_OP1, + 2153 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2178 | SPEC_RULE_OP1, + 2183, + 2184 | SPEC_RULE_OP1, + 2189 | SPEC_RULE_OP1, + 2194 | SPEC_RULE_OP1, + 2199, + 2200, + 2201 | SPEC_RULE_OP2, + 2206 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 2210 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 2214 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 2218 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2218 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2243 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2243 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2268 | SPEC_RULE_OP1, + 2273, + 2274 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2299, + 2300 | SPEC_RULE_OP1, + 2305, + 2306, + 2307, + 2308, + 2309, + 2310, + 2311, + 2312 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2337, + 2338, + 2339, + 2340 | SPEC_RULE_OP1, + 2345, + 2346 | SPEC_RULE_ISSET, + 2348 | SPEC_RULE_OP2, + 2353, + 2354 | SPEC_RULE_OP1, + 2359 | SPEC_RULE_OBSERVER, + 2361, + 2362 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2387 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 2397, + 2398, + 2399, + 2400, + 2401 | SPEC_RULE_OP1, + 2406, + 2407, + 2408 | SPEC_RULE_OP1, + 2413 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2438, + 2439 | SPEC_RULE_OP1, + 2444, + 2445, + 2446, + 2447, + 2448, + 2449, + 2450, + 2451, + 2452 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2477, + 2478, + 2479, + 2480 | SPEC_RULE_OP2, + 2485, 2486 | SPEC_RULE_OP1, - 2491, - 2492 | SPEC_RULE_OP1, - 2497 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2522 | SPEC_RULE_OP1, - 2527 | SPEC_RULE_OP2, - 2532 | SPEC_RULE_OP1, - 2537 | SPEC_RULE_OP1, - 2542, - 2543, - 2544, - 2545, - 2546, - 2547 | SPEC_RULE_OBSERVER, - 2549 | SPEC_RULE_OBSERVER, - 2551 | SPEC_RULE_OBSERVER, - 2553 | SPEC_RULE_OBSERVER, - 2555, - 2556, - 2557, - 2558, - 2559 | SPEC_RULE_OP2, - 2564 | SPEC_RULE_OP2, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, - 3484, + 2491 | SPEC_RULE_OP1, + 2496 | SPEC_RULE_OP1, + 2501 | SPEC_RULE_OP1, + 2506 | SPEC_RULE_OP1, + 2511, + 2512 | SPEC_RULE_OP1, + 2517 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2542 | SPEC_RULE_OP1, + 2547 | SPEC_RULE_OP2, + 2552 | SPEC_RULE_OP1, + 2557 | SPEC_RULE_OP1, + 2562, + 2563, + 2564, + 2565, + 2566, + 2567 | SPEC_RULE_OBSERVER, + 2569 | SPEC_RULE_OBSERVER, + 2571 | SPEC_RULE_OBSERVER, + 2573 | SPEC_RULE_OBSERVER, + 2575, + 2576, + 2577, + 2578, + 2579 | SPEC_RULE_OP2, + 2584 | SPEC_RULE_OP2, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, + 3504, }; #if 0 #elif (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) @@ -123525,7 +123878,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 = 2577 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2597 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -123533,7 +123886,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 = 2602 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2622 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -123541,7 +123894,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 = 2627 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2647 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -123552,17 +123905,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 = 2652 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2672 | 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 = 2677 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2697 | 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 = 2702 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2722 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -123573,17 +123926,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 = 2727 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2747 | 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 = 2752 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2772 | 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 = 2777 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2797 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -123594,19 +123947,19 @@ 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 = 2802 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2822 | 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 = 2877 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2897 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op2_type == IS_CONST && (Z_TYPE_P(RT_CONSTANT(op, op->op2)) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(RT_CONSTANT(op, op->op2))) == 0)) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3102 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3122 | 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)) && !((op1_info & op2_info) & MAY_BE_ARRAY_OF_ARRAY)) { - spec = 3108 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3128 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -123617,19 +123970,19 @@ 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 = 2952 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2972 | 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 = 3027 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3047 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op2_type == IS_CONST && (Z_TYPE_P(RT_CONSTANT(op, op->op2)) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(RT_CONSTANT(op, op->op2))) == 0)) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3105 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3125 | 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)) && !((op1_info & op2_info) & MAY_BE_ARRAY_OF_ARRAY)) { - spec = 3113 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3133 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -123640,12 +123993,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 = 2802 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2822 | 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 = 2877 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2897 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -123656,12 +124009,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 = 2952 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2972 | 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 = 3027 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3047 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -123669,12 +124022,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 = 3118 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3138 | 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 = 3193 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3213 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -123682,79 +124035,79 @@ 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 = 3268 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3288 | 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 = 3343 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3363 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3430 | SPEC_RULE_OP1; + spec = 3450 | SPEC_RULE_OP1; } else if (op1_info == MAY_BE_DOUBLE) { - spec = 3435 | SPEC_RULE_OP1; + spec = 3455 | 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 = 3440 | SPEC_RULE_OP1; + spec = 3460 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3418 | SPEC_RULE_RETVAL; + spec = 3438 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3420 | SPEC_RULE_RETVAL; + spec = 3440 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3422 | SPEC_RULE_RETVAL; + spec = 3442 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3424 | SPEC_RULE_RETVAL; + spec = 3444 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3426; + spec = 3446; } else if (op1_info == MAY_BE_LONG) { - spec = 3427; + spec = 3447; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3428; + spec = 3448; } else if (op1_info == MAY_BE_LONG) { - spec = 3429; + spec = 3449; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2576; + spec = 2596; } break; case ZEND_INIT_FCALL: if (Z_EXTRA_P(RT_CONSTANT(op, op->op2)) != 0) { - spec = 2569; + spec = 2589; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2570; + spec = 2590; } break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3480; + spec = 3500; } break; case ZEND_SEND_VAR_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3475 | SPEC_RULE_OP1; + spec = 3495 | SPEC_RULE_OP1; } break; case ZEND_FE_FETCH_R: if (op->op2_type == IS_CV && (op1_info & (MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 3482 | SPEC_RULE_RETVAL; + spec = 3502 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -123762,22 +124115,22 @@ 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 = 3445 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3465 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_SEND_VAL_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3481; + spec = 3501; } break; case ZEND_SEND_VAR: if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3470 | SPEC_RULE_OP1; + spec = 3490 | SPEC_RULE_OP1; } break; case ZEND_COUNT: if (op->op1_type != IS_CONST && (op1_info & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 2571 | SPEC_RULE_OP1; + spec = 2591 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 4586fd861021..7ec616206964 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -843,755 +843,758 @@ _(2148, ZEND_INIT_USER_CALL_SPEC_CONST_TMP) \ _(2151, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \ _(2152, ZEND_SEND_ARRAY_SPEC) \ - _(2153, ZEND_SEND_USER_SPEC_CONST) \ - _(2154, ZEND_SEND_USER_SPEC_TMP) \ - _(2157, ZEND_SEND_USER_SPEC_CV) \ - _(2158, ZEND_STRLEN_SPEC_CONST) \ - _(2159, ZEND_STRLEN_SPEC_TMP) \ - _(2162, ZEND_STRLEN_SPEC_CV) \ - _(2163, ZEND_DEFINED_SPEC_CONST) \ - _(2164, ZEND_TYPE_CHECK_SPEC_CONST) \ - _(2165, ZEND_TYPE_CHECK_SPEC_TMP) \ - _(2168, ZEND_TYPE_CHECK_SPEC_CV) \ - _(2169, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \ - _(2170, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \ - _(2171, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \ - _(2172, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \ - _(2173, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \ - _(2174, ZEND_FE_RESET_RW_SPEC_CONST) \ - _(2175, ZEND_FE_RESET_RW_SPEC_TMP) \ - _(2176, ZEND_FE_RESET_RW_SPEC_VAR) \ - _(2178, ZEND_FE_RESET_RW_SPEC_CV) \ - _(2179, ZEND_FE_FETCH_RW_SPEC_VAR) \ - _(2180, ZEND_FE_FREE_SPEC_TMPVAR) \ - _(2181, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \ - _(2182, ZEND_INIT_DYNAMIC_CALL_SPEC_TMP) \ - _(2185, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \ - _(2186, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \ - _(2187, ZEND_DO_ICALL_SPEC_RETVAL_USED) \ - _(2188, ZEND_DO_ICALL_SPEC_OBSERVER) \ - _(2189, ZEND_DO_ICALL_SPEC_OBSERVER) \ - _(2190, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \ - _(2191, ZEND_DO_UCALL_SPEC_RETVAL_USED) \ - _(2192, ZEND_DO_UCALL_SPEC_OBSERVER) \ - _(2193, ZEND_DO_UCALL_SPEC_OBSERVER) \ - _(2194, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \ - _(2195, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \ - _(2196, ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER) \ - _(2197, ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER) \ - _(2208, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \ - _(2209, ZEND_PRE_INC_OBJ_SPEC_VAR_TMP) \ - _(2212, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \ - _(2213, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \ - _(2214, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP) \ - _(2217, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \ - _(2218, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \ - _(2219, ZEND_PRE_INC_OBJ_SPEC_CV_TMP) \ - _(2222, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \ - _(2233, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \ - _(2234, ZEND_POST_INC_OBJ_SPEC_VAR_TMP) \ - _(2237, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \ - _(2238, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \ - _(2239, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP) \ - _(2242, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \ - _(2243, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \ - _(2244, ZEND_POST_INC_OBJ_SPEC_CV_TMP) \ - _(2247, ZEND_POST_INC_OBJ_SPEC_CV_CV) \ - _(2248, ZEND_ECHO_SPEC_CONST) \ - _(2249, ZEND_ECHO_SPEC_TMP) \ - _(2252, ZEND_ECHO_SPEC_CV) \ - _(2259, ZEND_INSTANCEOF_SPEC_TMP_CONST) \ - _(2261, ZEND_INSTANCEOF_SPEC_TMP_VAR) \ - _(2262, ZEND_INSTANCEOF_SPEC_TMP_UNUSED) \ - _(2274, ZEND_INSTANCEOF_SPEC_CV_CONST) \ - _(2276, ZEND_INSTANCEOF_SPEC_CV_VAR) \ - _(2277, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \ - _(2279, ZEND_GENERATOR_CREATE_SPEC) \ - _(2282, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \ - _(2284, ZEND_MAKE_REF_SPEC_CV_UNUSED) \ - _(2285, ZEND_DECLARE_FUNCTION_SPEC) \ - _(2286, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_UNUSED) \ - _(2287, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ - _(2288, ZEND_DECLARE_CLASS_SPEC_CONST) \ - _(2289, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \ - _(2290, ZEND_DECLARE_ANON_CLASS_SPEC) \ - _(2291, ZEND_ADD_ARRAY_UNPACK_SPEC) \ - _(2292, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ - _(2293, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMP) \ - _(2296, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ - _(2297, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CONST) \ - _(2298, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_TMP) \ - _(2301, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CV) \ - _(2307, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ - _(2308, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP) \ - _(2311, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ - _(2312, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ - _(2313, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP) \ - _(2316, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ - _(2317, ZEND_HANDLE_EXCEPTION_SPEC) \ - _(2318, ZEND_USER_OPCODE_SPEC) \ - _(2319, ZEND_ASSERT_CHECK_SPEC) \ - _(2320, ZEND_JMP_SET_SPEC_CONST) \ - _(2321, ZEND_JMP_SET_SPEC_TMP) \ - _(2324, ZEND_JMP_SET_SPEC_CV) \ - _(2325, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ - _(2326, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ - _(2327, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ - _(2328, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ - _(2329, ZEND_FETCH_LIST_W_SPEC_VAR_TMP) \ - _(2332, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ - _(2333, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ - _(2335, ZEND_FETCH_CLASS_NAME_SPEC_TMP) \ - _(2337, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ - _(2338, ZEND_FETCH_CLASS_NAME_SPEC_CV) \ - _(2339, ZEND_CALL_TRAMPOLINE_SPEC) \ - _(2340, ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER) \ - _(2341, ZEND_DISCARD_EXCEPTION_SPEC) \ - _(2342, ZEND_YIELD_SPEC_CONST_CONST) \ - _(2343, ZEND_YIELD_SPEC_CONST_TMP) \ - _(2345, ZEND_YIELD_SPEC_CONST_UNUSED) \ - _(2346, ZEND_YIELD_SPEC_CONST_CV) \ - _(2347, ZEND_YIELD_SPEC_TMP_CONST) \ - _(2348, ZEND_YIELD_SPEC_TMP_TMP) \ - _(2350, ZEND_YIELD_SPEC_TMP_UNUSED) \ - _(2351, ZEND_YIELD_SPEC_TMP_CV) \ - _(2352, ZEND_YIELD_SPEC_VAR_CONST) \ - _(2353, ZEND_YIELD_SPEC_VAR_TMP) \ - _(2355, ZEND_YIELD_SPEC_VAR_UNUSED) \ - _(2356, ZEND_YIELD_SPEC_VAR_CV) \ - _(2357, ZEND_YIELD_SPEC_UNUSED_CONST) \ - _(2358, ZEND_YIELD_SPEC_UNUSED_TMP) \ - _(2360, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ - _(2361, ZEND_YIELD_SPEC_UNUSED_CV) \ - _(2362, ZEND_YIELD_SPEC_CV_CONST) \ - _(2363, ZEND_YIELD_SPEC_CV_TMP) \ - _(2365, ZEND_YIELD_SPEC_CV_UNUSED) \ - _(2366, ZEND_YIELD_SPEC_CV_CV) \ - _(2367, ZEND_GENERATOR_RETURN_SPEC_CONST) \ - _(2368, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ - _(2369, ZEND_GENERATOR_RETURN_SPEC_TMP) \ - _(2370, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ - _(2371, ZEND_GENERATOR_RETURN_SPEC_VAR) \ - _(2372, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ - _(2375, ZEND_GENERATOR_RETURN_SPEC_CV) \ - _(2376, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ - _(2377, ZEND_FAST_CALL_SPEC) \ - _(2378, ZEND_FAST_RET_SPEC) \ - _(2379, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ - _(2380, ZEND_SEND_UNPACK_SPEC) \ - _(2381, ZEND_YIELD_FROM_SPEC_CONST) \ - _(2382, ZEND_YIELD_FROM_SPEC_TMP) \ - _(2385, ZEND_YIELD_FROM_SPEC_CV) \ - _(2386, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ - _(2387, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ - _(2388, ZEND_COALESCE_SPEC_CONST) \ - _(2389, ZEND_COALESCE_SPEC_TMP) \ - _(2392, ZEND_COALESCE_SPEC_CV) \ - _(2393, ZEND_SPACESHIP_SPEC_CONST_CONST) \ - _(2394, ZEND_SPACESHIP_SPEC_CONST_TMP) \ - _(2397, ZEND_SPACESHIP_SPEC_CONST_CV) \ - _(2398, ZEND_SPACESHIP_SPEC_TMP_CONST) \ - _(2399, ZEND_SPACESHIP_SPEC_TMP_TMP) \ - _(2402, ZEND_SPACESHIP_SPEC_TMP_CV) \ - _(2413, ZEND_SPACESHIP_SPEC_CV_CONST) \ - _(2414, ZEND_SPACESHIP_SPEC_CV_TMP) \ - _(2417, ZEND_SPACESHIP_SPEC_CV_CV) \ - _(2418, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ - _(2419, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ - _(2422, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ - _(2424, ZEND_FETCH_STATIC_PROP_R_SPEC) \ - _(2425, ZEND_FETCH_STATIC_PROP_W_SPEC) \ - _(2426, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ - _(2427, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ - _(2428, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ - _(2429, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ - _(2430, ZEND_UNSET_STATIC_PROP_SPEC) \ - _(2431, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ - _(2432, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ - _(2433, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ - _(2434, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ - _(2436, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ - _(2442, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ - _(2443, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ - _(2444, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ - _(2446, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ - _(2447, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ - _(2448, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ - _(2449, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ - _(2451, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ - _(2457, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ - _(2458, ZEND_BIND_STATIC_SPEC_CV) \ - _(2459, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ - _(2460, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \ - _(2463, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \ - _(2465, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ - _(2466, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ - _(2467, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2468, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2470, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2471, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ - _(2472, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2473, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2475, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2476, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ - _(2477, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ - _(2480, ZEND_IN_ARRAY_SPEC_CV_CONST) \ - _(2481, ZEND_COUNT_SPEC_CONST_UNUSED) \ - _(2482, ZEND_COUNT_SPEC_TMP_UNUSED) \ - _(2485, ZEND_COUNT_SPEC_CV_UNUSED) \ - _(2486, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ - _(2487, ZEND_GET_CLASS_SPEC_TMP_UNUSED) \ - _(2489, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ - _(2490, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ - _(2491, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ - _(2492, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ - _(2493, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ - _(2496, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ - _(2497, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ - _(2498, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMP) \ - _(2501, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ - _(2502, ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CONST) \ - _(2503, ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_TMP) \ - _(2506, ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CV) \ - _(2517, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ - _(2518, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMP) \ - _(2521, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ - _(2522, ZEND_MATCH_SPEC_CONST_CONST) \ - _(2523, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2524, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2526, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2527, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ - _(2528, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ - _(2531, ZEND_CASE_STRICT_SPEC_TMP_CV) \ - _(2532, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ - _(2533, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2534, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2536, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2537, ZEND_JMP_NULL_SPEC_CONST) \ - _(2538, ZEND_JMP_NULL_SPEC_TMP) \ - _(2541, ZEND_JMP_NULL_SPEC_CV) \ - _(2542, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ - _(2543, ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED) \ - _(2544, ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED) \ - _(2545, ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED) \ - _(2546, ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV) \ - _(2547, ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED) \ - _(2548, ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER) \ - _(2549, ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED) \ - _(2550, ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER) \ - _(2551, ZEND_FRAMELESS_ICALL_2_SPEC) \ - _(2552, ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER) \ - _(2553, ZEND_FRAMELESS_ICALL_3_SPEC) \ - _(2554, ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER) \ - _(2555, ZEND_JMP_FRAMELESS_SPEC_CONST) \ - _(2556, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED) \ - _(2557, ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST) \ - _(2558, ZEND_TYPE_ASSERT_SPEC_CONST) \ - _(2559, ZEND_CALLABLE_CONVERT_PARTIAL_SPEC_CONST_CONST) \ - _(2562, ZEND_CALLABLE_CONVERT_PARTIAL_SPEC_CONST_UNUSED) \ - _(2564, ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_CONST) \ - _(2567, ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_UNUSED) \ - _(2569, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \ - _(2570, ZEND_RECV_NOTYPE_SPEC) \ - _(2572, ZEND_COUNT_ARRAY_SPEC_TMP_UNUSED) \ - _(2575, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \ - _(2576, ZEND_JMP_FORWARD_SPEC) \ - _(2582, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2583, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2584, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2586, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2587, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2588, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2589, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2591, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2597, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2598, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2599, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2601, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2607, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2608, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2609, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2611, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2612, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2613, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2614, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2616, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2622, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2623, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2624, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2626, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2632, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2633, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2634, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2636, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2637, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2638, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2639, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2641, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2647, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2648, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2649, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2651, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2653, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2654, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2656, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2657, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2658, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2659, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2661, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2662, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2663, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2664, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2666, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2672, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2673, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2674, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2676, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2678, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2679, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2681, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2682, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2683, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2684, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2686, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2687, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2688, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2689, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2691, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2697, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2698, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2699, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2701, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2703, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2704, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2706, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2707, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2708, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2709, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2711, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2712, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2713, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2714, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2716, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2722, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2723, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2724, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2726, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2732, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2733, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2734, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2736, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2737, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2738, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2739, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2741, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2747, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2748, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2749, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2751, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2757, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2758, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2759, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2761, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2762, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2763, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2764, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2766, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2772, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2773, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2774, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2776, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2782, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2783, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2784, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2786, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2787, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2788, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2789, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2791, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2797, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2798, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2799, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2801, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2817, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2818, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2819, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2820, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2821, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2822, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2823, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2824, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2825, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2829, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2830, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2831, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2832, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2845, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2862, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2863, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2864, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2865, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2866, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2867, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2868, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2869, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2870, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2874, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2875, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2876, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2892, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2893, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2894, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2895, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2896, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2897, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2898, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2899, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2900, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2904, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2905, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2906, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2907, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2920, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2937, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2938, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2939, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2940, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2941, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2942, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2943, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2944, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2945, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2949, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2950, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2951, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2967, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2968, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2969, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2970, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2971, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2972, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2973, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2974, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2975, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2979, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2980, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2981, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2982, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3012, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3013, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3014, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3015, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3016, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3017, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3018, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3019, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3020, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3024, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3025, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3026, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3042, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3043, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3044, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3045, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3046, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3047, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3048, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3049, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3050, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3054, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3055, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3056, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3057, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3087, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3088, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3089, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3090, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3091, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3092, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3093, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3094, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3095, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3099, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3100, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3101, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3102, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ - _(3103, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3104, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3105, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ - _(3106, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3107, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3108, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3112, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3113, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3117, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3121, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3122, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3123, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3124, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3125, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3126, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3130, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3131, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3132, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3133, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3134, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3135, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3136, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3137, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3138, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3139, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3140, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3141, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3152, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3153, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3154, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3160, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3161, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3162, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3178, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3179, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3180, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3181, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3182, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3183, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3184, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3185, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3186, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3190, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3191, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3192, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3196, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3197, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3198, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3199, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3200, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3201, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3205, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3206, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3207, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3208, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3209, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3210, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3211, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3212, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3213, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3214, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3235, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3236, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3237, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3253, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3254, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3255, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3256, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3257, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3258, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3259, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3260, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3261, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3265, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3266, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3267, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3271, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3272, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3273, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3280, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3281, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3282, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3283, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3284, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3285, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3286, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3287, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3288, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3289, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3310, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3311, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3312, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3328, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3329, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3330, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3331, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3332, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3333, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3334, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3335, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3336, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3340, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3341, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3342, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3346, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3347, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3348, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3355, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3356, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3357, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3358, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3359, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3360, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3361, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3362, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3363, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3364, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3385, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3386, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3387, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3403, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3404, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3405, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3406, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3407, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3408, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3409, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3410, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3411, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3415, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3416, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3417, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3418, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3419, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3420, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3421, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3422, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3423, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3424, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3425, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3426, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3427, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3428, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3429, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3430, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ - _(3431, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3432, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3434, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3435, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(3436, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3437, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3439, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3440, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(3441, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3442, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3444, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3446, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3447, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3449, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3450, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3451, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3452, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3454, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3455, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3456, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3457, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3459, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3465, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(3466, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3467, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3469, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3472, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3474, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3477, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ - _(3479, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ - _(3480, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3481, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3482, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3483, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3483+1, ZEND_NULL) + _(2153, ZEND_SEND_USER_SPEC_CONST_CONST) \ + _(2156, ZEND_SEND_USER_SPEC_CONST_UNUSED) \ + _(2158, ZEND_SEND_USER_SPEC_TMP_CONST) \ + _(2161, ZEND_SEND_USER_SPEC_TMP_UNUSED) \ + _(2173, ZEND_SEND_USER_SPEC_CV_CONST) \ + _(2176, ZEND_SEND_USER_SPEC_CV_UNUSED) \ + _(2178, ZEND_STRLEN_SPEC_CONST) \ + _(2179, ZEND_STRLEN_SPEC_TMP) \ + _(2182, ZEND_STRLEN_SPEC_CV) \ + _(2183, ZEND_DEFINED_SPEC_CONST) \ + _(2184, ZEND_TYPE_CHECK_SPEC_CONST) \ + _(2185, ZEND_TYPE_CHECK_SPEC_TMP) \ + _(2188, ZEND_TYPE_CHECK_SPEC_CV) \ + _(2189, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \ + _(2190, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \ + _(2191, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \ + _(2192, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \ + _(2193, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \ + _(2194, ZEND_FE_RESET_RW_SPEC_CONST) \ + _(2195, ZEND_FE_RESET_RW_SPEC_TMP) \ + _(2196, ZEND_FE_RESET_RW_SPEC_VAR) \ + _(2198, ZEND_FE_RESET_RW_SPEC_CV) \ + _(2199, ZEND_FE_FETCH_RW_SPEC_VAR) \ + _(2200, ZEND_FE_FREE_SPEC_TMPVAR) \ + _(2201, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \ + _(2202, ZEND_INIT_DYNAMIC_CALL_SPEC_TMP) \ + _(2205, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \ + _(2206, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \ + _(2207, ZEND_DO_ICALL_SPEC_RETVAL_USED) \ + _(2208, ZEND_DO_ICALL_SPEC_OBSERVER) \ + _(2209, ZEND_DO_ICALL_SPEC_OBSERVER) \ + _(2210, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \ + _(2211, ZEND_DO_UCALL_SPEC_RETVAL_USED) \ + _(2212, ZEND_DO_UCALL_SPEC_OBSERVER) \ + _(2213, ZEND_DO_UCALL_SPEC_OBSERVER) \ + _(2214, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \ + _(2215, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \ + _(2216, ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER) \ + _(2217, ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER) \ + _(2228, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \ + _(2229, ZEND_PRE_INC_OBJ_SPEC_VAR_TMP) \ + _(2232, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \ + _(2233, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2234, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP) \ + _(2237, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \ + _(2238, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \ + _(2239, ZEND_PRE_INC_OBJ_SPEC_CV_TMP) \ + _(2242, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \ + _(2253, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \ + _(2254, ZEND_POST_INC_OBJ_SPEC_VAR_TMP) \ + _(2257, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \ + _(2258, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2259, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP) \ + _(2262, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \ + _(2263, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \ + _(2264, ZEND_POST_INC_OBJ_SPEC_CV_TMP) \ + _(2267, ZEND_POST_INC_OBJ_SPEC_CV_CV) \ + _(2268, ZEND_ECHO_SPEC_CONST) \ + _(2269, ZEND_ECHO_SPEC_TMP) \ + _(2272, ZEND_ECHO_SPEC_CV) \ + _(2279, ZEND_INSTANCEOF_SPEC_TMP_CONST) \ + _(2281, ZEND_INSTANCEOF_SPEC_TMP_VAR) \ + _(2282, ZEND_INSTANCEOF_SPEC_TMP_UNUSED) \ + _(2294, ZEND_INSTANCEOF_SPEC_CV_CONST) \ + _(2296, ZEND_INSTANCEOF_SPEC_CV_VAR) \ + _(2297, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \ + _(2299, ZEND_GENERATOR_CREATE_SPEC) \ + _(2302, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \ + _(2304, ZEND_MAKE_REF_SPEC_CV_UNUSED) \ + _(2305, ZEND_DECLARE_FUNCTION_SPEC) \ + _(2306, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_UNUSED) \ + _(2307, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ + _(2308, ZEND_DECLARE_CLASS_SPEC_CONST) \ + _(2309, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \ + _(2310, ZEND_DECLARE_ANON_CLASS_SPEC) \ + _(2311, ZEND_ADD_ARRAY_UNPACK_SPEC) \ + _(2312, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ + _(2313, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMP) \ + _(2316, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ + _(2317, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CONST) \ + _(2318, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_TMP) \ + _(2321, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CV) \ + _(2327, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ + _(2328, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP) \ + _(2331, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ + _(2332, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ + _(2333, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP) \ + _(2336, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ + _(2337, ZEND_HANDLE_EXCEPTION_SPEC) \ + _(2338, ZEND_USER_OPCODE_SPEC) \ + _(2339, ZEND_ASSERT_CHECK_SPEC) \ + _(2340, ZEND_JMP_SET_SPEC_CONST) \ + _(2341, ZEND_JMP_SET_SPEC_TMP) \ + _(2344, ZEND_JMP_SET_SPEC_CV) \ + _(2345, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ + _(2346, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ + _(2347, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ + _(2348, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ + _(2349, ZEND_FETCH_LIST_W_SPEC_VAR_TMP) \ + _(2352, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ + _(2353, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ + _(2355, ZEND_FETCH_CLASS_NAME_SPEC_TMP) \ + _(2357, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ + _(2358, ZEND_FETCH_CLASS_NAME_SPEC_CV) \ + _(2359, ZEND_CALL_TRAMPOLINE_SPEC) \ + _(2360, ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER) \ + _(2361, ZEND_DISCARD_EXCEPTION_SPEC) \ + _(2362, ZEND_YIELD_SPEC_CONST_CONST) \ + _(2363, ZEND_YIELD_SPEC_CONST_TMP) \ + _(2365, ZEND_YIELD_SPEC_CONST_UNUSED) \ + _(2366, ZEND_YIELD_SPEC_CONST_CV) \ + _(2367, ZEND_YIELD_SPEC_TMP_CONST) \ + _(2368, ZEND_YIELD_SPEC_TMP_TMP) \ + _(2370, ZEND_YIELD_SPEC_TMP_UNUSED) \ + _(2371, ZEND_YIELD_SPEC_TMP_CV) \ + _(2372, ZEND_YIELD_SPEC_VAR_CONST) \ + _(2373, ZEND_YIELD_SPEC_VAR_TMP) \ + _(2375, ZEND_YIELD_SPEC_VAR_UNUSED) \ + _(2376, ZEND_YIELD_SPEC_VAR_CV) \ + _(2377, ZEND_YIELD_SPEC_UNUSED_CONST) \ + _(2378, ZEND_YIELD_SPEC_UNUSED_TMP) \ + _(2380, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ + _(2381, ZEND_YIELD_SPEC_UNUSED_CV) \ + _(2382, ZEND_YIELD_SPEC_CV_CONST) \ + _(2383, ZEND_YIELD_SPEC_CV_TMP) \ + _(2385, ZEND_YIELD_SPEC_CV_UNUSED) \ + _(2386, ZEND_YIELD_SPEC_CV_CV) \ + _(2387, ZEND_GENERATOR_RETURN_SPEC_CONST) \ + _(2388, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ + _(2389, ZEND_GENERATOR_RETURN_SPEC_TMP) \ + _(2390, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ + _(2391, ZEND_GENERATOR_RETURN_SPEC_VAR) \ + _(2392, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ + _(2395, ZEND_GENERATOR_RETURN_SPEC_CV) \ + _(2396, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ + _(2397, ZEND_FAST_CALL_SPEC) \ + _(2398, ZEND_FAST_RET_SPEC) \ + _(2399, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ + _(2400, ZEND_SEND_UNPACK_SPEC) \ + _(2401, ZEND_YIELD_FROM_SPEC_CONST) \ + _(2402, ZEND_YIELD_FROM_SPEC_TMP) \ + _(2405, ZEND_YIELD_FROM_SPEC_CV) \ + _(2406, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ + _(2407, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ + _(2408, ZEND_COALESCE_SPEC_CONST) \ + _(2409, ZEND_COALESCE_SPEC_TMP) \ + _(2412, ZEND_COALESCE_SPEC_CV) \ + _(2413, ZEND_SPACESHIP_SPEC_CONST_CONST) \ + _(2414, ZEND_SPACESHIP_SPEC_CONST_TMP) \ + _(2417, ZEND_SPACESHIP_SPEC_CONST_CV) \ + _(2418, ZEND_SPACESHIP_SPEC_TMP_CONST) \ + _(2419, ZEND_SPACESHIP_SPEC_TMP_TMP) \ + _(2422, ZEND_SPACESHIP_SPEC_TMP_CV) \ + _(2433, ZEND_SPACESHIP_SPEC_CV_CONST) \ + _(2434, ZEND_SPACESHIP_SPEC_CV_TMP) \ + _(2437, ZEND_SPACESHIP_SPEC_CV_CV) \ + _(2438, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ + _(2439, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ + _(2442, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ + _(2444, ZEND_FETCH_STATIC_PROP_R_SPEC) \ + _(2445, ZEND_FETCH_STATIC_PROP_W_SPEC) \ + _(2446, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ + _(2447, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ + _(2448, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ + _(2449, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ + _(2450, ZEND_UNSET_STATIC_PROP_SPEC) \ + _(2451, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ + _(2452, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ + _(2453, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ + _(2454, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ + _(2456, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ + _(2462, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ + _(2463, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ + _(2464, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ + _(2466, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ + _(2467, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ + _(2468, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ + _(2469, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ + _(2471, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ + _(2477, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ + _(2478, ZEND_BIND_STATIC_SPEC_CV) \ + _(2479, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ + _(2480, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \ + _(2483, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \ + _(2485, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ + _(2486, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ + _(2487, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2488, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2490, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2491, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ + _(2492, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2493, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2495, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2496, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ + _(2497, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ + _(2500, ZEND_IN_ARRAY_SPEC_CV_CONST) \ + _(2501, ZEND_COUNT_SPEC_CONST_UNUSED) \ + _(2502, ZEND_COUNT_SPEC_TMP_UNUSED) \ + _(2505, ZEND_COUNT_SPEC_CV_UNUSED) \ + _(2506, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ + _(2507, ZEND_GET_CLASS_SPEC_TMP_UNUSED) \ + _(2509, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ + _(2510, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ + _(2511, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ + _(2512, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ + _(2513, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ + _(2516, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ + _(2517, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ + _(2518, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMP) \ + _(2521, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ + _(2522, ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CONST) \ + _(2523, ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_TMP) \ + _(2526, ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CV) \ + _(2537, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ + _(2538, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMP) \ + _(2541, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ + _(2542, ZEND_MATCH_SPEC_CONST_CONST) \ + _(2543, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2544, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2546, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2547, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ + _(2548, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ + _(2551, ZEND_CASE_STRICT_SPEC_TMP_CV) \ + _(2552, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ + _(2553, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2554, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2556, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2557, ZEND_JMP_NULL_SPEC_CONST) \ + _(2558, ZEND_JMP_NULL_SPEC_TMP) \ + _(2561, ZEND_JMP_NULL_SPEC_CV) \ + _(2562, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ + _(2563, ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED) \ + _(2564, ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED) \ + _(2565, ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED) \ + _(2566, ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV) \ + _(2567, ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED) \ + _(2568, ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER) \ + _(2569, ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED) \ + _(2570, ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER) \ + _(2571, ZEND_FRAMELESS_ICALL_2_SPEC) \ + _(2572, ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER) \ + _(2573, ZEND_FRAMELESS_ICALL_3_SPEC) \ + _(2574, ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER) \ + _(2575, ZEND_JMP_FRAMELESS_SPEC_CONST) \ + _(2576, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED) \ + _(2577, ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST) \ + _(2578, ZEND_TYPE_ASSERT_SPEC_CONST) \ + _(2579, ZEND_CALLABLE_CONVERT_PARTIAL_SPEC_CONST_CONST) \ + _(2582, ZEND_CALLABLE_CONVERT_PARTIAL_SPEC_CONST_UNUSED) \ + _(2584, ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_CONST) \ + _(2587, ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_UNUSED) \ + _(2589, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \ + _(2590, ZEND_RECV_NOTYPE_SPEC) \ + _(2592, ZEND_COUNT_ARRAY_SPEC_TMP_UNUSED) \ + _(2595, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \ + _(2596, ZEND_JMP_FORWARD_SPEC) \ + _(2602, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2603, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2604, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2606, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2607, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2608, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2609, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2611, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2617, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2618, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2619, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2621, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2627, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2628, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2629, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2631, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2632, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2633, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2634, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2636, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2642, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2643, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2644, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2646, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2652, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2653, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2654, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2656, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2657, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2658, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2659, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2661, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2667, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2668, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2669, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2671, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2673, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2674, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2676, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2677, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2678, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2679, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2681, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2682, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2683, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2684, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2686, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2692, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2693, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2694, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2696, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2698, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2699, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2701, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2702, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2703, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2704, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2706, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2707, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2708, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2709, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2711, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2717, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2718, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2719, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2721, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2723, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2724, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2726, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2727, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2728, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2729, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2731, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2732, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2733, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2734, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2736, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2742, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2743, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2744, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2746, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2752, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2753, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2754, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2756, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2757, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2758, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2759, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2761, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2767, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2768, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2769, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2771, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2777, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2778, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2779, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2781, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2782, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2783, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2784, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2786, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2792, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2793, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2794, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2796, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2802, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2803, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2804, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2806, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2807, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2808, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2809, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2811, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2817, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2818, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2819, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2821, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2845, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2849, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2850, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2851, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2852, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2853, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2854, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2855, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2856, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2857, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2858, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2859, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2860, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2864, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2865, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2866, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2882, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2883, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2884, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2885, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2886, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2887, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2888, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2889, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2890, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2894, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2895, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2896, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2920, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2924, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2925, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2926, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2927, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2928, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2929, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2930, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2931, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2932, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2933, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2934, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2935, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2939, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2940, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2941, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2957, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2958, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2959, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2960, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2961, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2962, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2963, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2964, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2965, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2969, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2970, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2971, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2999, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3000, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3001, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3002, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3003, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3004, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3005, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3006, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3007, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3008, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3009, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3010, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3014, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3015, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3016, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3032, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3033, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3034, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3035, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3036, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3037, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3038, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3039, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3040, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3044, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3045, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3046, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3074, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3075, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3076, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3077, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3078, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3079, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3080, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3081, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3082, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3083, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3084, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3085, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3089, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3090, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3091, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3107, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3108, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3109, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3110, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3111, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3112, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3113, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3114, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3115, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3119, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3120, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3121, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3122, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ + _(3123, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3124, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3125, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ + _(3126, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3127, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3128, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3132, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3133, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3137, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3141, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3142, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3143, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3144, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3145, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3146, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3150, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3151, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3152, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3153, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3154, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3158, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3159, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3160, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3161, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3165, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3166, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3167, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3168, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3169, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3170, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3171, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3172, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3173, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3174, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3175, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3176, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3180, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3181, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3182, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3198, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3199, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3200, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3201, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3202, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3203, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3204, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3205, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3206, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3210, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3211, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3212, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3217, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3233, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3234, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3235, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3236, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3240, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3241, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3242, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3243, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3244, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3245, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3246, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3247, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3248, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3249, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3250, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3251, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3255, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3256, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3257, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3273, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3274, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3275, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3276, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3277, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3278, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3279, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3280, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3281, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3285, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3286, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3287, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3308, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3309, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3310, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3311, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3315, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3316, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3317, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3318, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3319, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3320, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3321, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3322, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3323, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3324, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3325, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3326, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3330, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3331, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3332, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3348, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3349, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3350, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3351, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3352, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3353, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3354, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3355, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3356, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3360, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3361, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3362, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3383, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3384, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3385, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3386, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3390, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3391, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3392, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3393, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3394, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3395, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3396, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3397, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3398, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3399, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3400, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3401, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3405, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3406, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3407, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3423, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3424, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3425, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3426, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3427, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3428, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3429, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3430, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3431, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3435, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3436, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3437, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3438, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3439, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3440, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3441, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3442, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3443, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3444, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3445, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3446, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3447, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3448, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3449, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3450, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3451, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3452, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3454, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3455, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3456, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3457, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3459, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3460, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3461, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3462, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3464, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3466, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3467, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3469, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3470, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3471, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3472, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3474, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3475, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3476, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3477, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3479, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3485, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3486, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3487, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3489, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3492, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3494, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3497, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ + _(3499, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ + _(3500, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3501, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3502, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3503, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3503+1, ZEND_NULL) diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index cc14862ebedd..d693242397dd 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -359,7 +359,7 @@ static uint32_t zend_vm_opcodes_flags[214] = { 0x00001301, 0x01000303, 0x01000000, - 0x00001003, + 0x00001303, 0x00000003, 0x00040003, 0x09000003, diff --git a/ext/opcache/tests/array_map_foreach_optimization_006.phpt b/ext/opcache/tests/array_map_foreach_optimization_006.phpt index 4c557ce6802c..269c49e54964 100644 --- a/ext/opcache/tests/array_map_foreach_optimization_006.phpt +++ b/ext/opcache/tests/array_map_foreach_optimization_006.phpt @@ -39,7 +39,7 @@ $_main: 0010 T7 = FE_FETCH_R V5 T6 0017 0011 T8 = COPY_TMP T4 0012 INIT_DYNAMIC_CALL 1 T8 -0013 SEND_VAL_EX T6 1 +0013 SEND_USER T6 1 0014 T6 = DO_FCALL 0015 T3 = ADD_ARRAY_ELEMENT T6 T7 0016 JMP 0010 diff --git a/ext/opcache/tests/array_map_foreach_optimization_012.phpt b/ext/opcache/tests/array_map_foreach_optimization_012.phpt index 04b16d2ab6dd..195c896baf73 100644 --- a/ext/opcache/tests/array_map_foreach_optimization_012.phpt +++ b/ext/opcache/tests/array_map_foreach_optimization_012.phpt @@ -64,7 +64,7 @@ $_main: 0011 T8 = FE_FETCH_R V4 T7 0018 0012 T9 = COPY_TMP T3 0013 INIT_DYNAMIC_CALL 1 T9 -0014 SEND_VAL_EX T7 1 +0014 SEND_USER T7 1 0015 T7 = DO_FCALL 0016 T2 = ADD_ARRAY_ELEMENT T7 T8 0017 JMP 0011 @@ -82,7 +82,7 @@ $_main: 0029 T9 = COPY_TMP T3 0030 V8 = FETCH_CLASS (exception) T9 0031 INIT_STATIC_METHOD_CALL 1 V8 string("f") -0032 SEND_VAL_EX T6 1 +0032 SEND_USER T6 1 0033 T6 = DO_FCALL 0034 T2 = ADD_ARRAY_ELEMENT T6 T7 0035 JMP 0028 @@ -101,7 +101,7 @@ $_main: 0048 T6 = FE_FETCH_R V4 T5 0055 0049 T7 = COPY_TMP T3 0050 INIT_DYNAMIC_CALL 1 T7 -0051 SEND_VAL_EX T5 1 +0051 SEND_USER T5 1 0052 T5 = DO_FCALL 0053 T2 = ADD_ARRAY_ELEMENT T5 T6 0054 JMP 0048 diff --git a/ext/opcache/tests/array_map_foreach_optimization_014.phpt b/ext/opcache/tests/array_map_foreach_optimization_014.phpt index c6c4afc216ae..2320b0fa9d3e 100644 --- a/ext/opcache/tests/array_map_foreach_optimization_014.phpt +++ b/ext/opcache/tests/array_map_foreach_optimization_014.phpt @@ -40,7 +40,7 @@ $_main: 0012 V1 = FE_RESET_R T3 0020 0013 T3 = FE_FETCH_R V1 T2 0020 0014 INIT_FCALL_BY_NAME 2 string("plusn") -0015 SEND_VAL_EX T2 1 +0015 SEND_USER T2 1 0016 SEND_VAL_EX int(2) 2 0017 T2 = DO_FCALL_BY_NAME 0018 T0 = ADD_ARRAY_ELEMENT T2 T3 From b441b3129986824ecbb21b2cb30da44554f426d8 Mon Sep 17 00:00:00 2001 From: Pratik Bhujel Date: Thu, 19 Nov 2026 22:28:55 +0545 Subject: [PATCH 2/6] Fix GH-25379: preserve reference elements for by-ref array_map callbacks --- ...timization_gh25379_reference_elements.phpt | 66 ++++++++++++++++ Zend/zend_compile.c | 76 ++++++++++++++++++- 2 files changed, 141 insertions(+), 1 deletion(-) create mode 100644 Zend/tests/array_map_foreach_optimization_gh25379_reference_elements.phpt diff --git a/Zend/tests/array_map_foreach_optimization_gh25379_reference_elements.phpt b/Zend/tests/array_map_foreach_optimization_gh25379_reference_elements.phpt new file mode 100644 index 000000000000..984996fa8579 --- /dev/null +++ b/Zend/tests/array_map_foreach_optimization_gh25379_reference_elements.phpt @@ -0,0 +1,66 @@ +--TEST-- +GH-25379: array_map() foreach optimization preserves by-ref callbacks with reference elements +--FILE-- +getMessage(), PHP_EOL; + } +} +test('known callee', function () { + $a = [1, 2]; + $r = &$a[0]; + $res = array_map(known(...), $a); + return [$res, $a]; +}); +test('callee declared later', function () { + $a = [1, 2]; + $r = &$a[0]; + $res = array_map(later(...), $a); + return [$res, $a]; +}); +test('static method', function () { + $a = [1, 2]; + $r = &$a[0]; + $res = array_map(ByRefMethod::change(...), $a); + return [$res, $a]; +}); +test('by-value callee', function () { + $a = [1, 2]; + $r = &$a[0]; + $res = array_map(byValue(...), $a); + return [$res, $a]; +}); +function later(&$x) { + return ++$x; +} +?> +--EXPECTF-- +known callee: + +Warning: known(): Argument #1 ($x) must be passed by reference, value given in %s on line %d +[[2,3],[2,2]] +callee declared later: + +Warning: later(): Argument #1 ($x) must be passed by reference, value given in %s on line %d +[[2,3],[2,2]] +static method: + +Warning: ByRefMethod::change(): Argument #1 ($x) must be passed by reference, value given in %s on line %d +[[2,3],[2,2]] +by-value callee: +[[2,3],[1,2]] diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index ba40acf516d2..78790b088ad1 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -5354,6 +5354,74 @@ static const zend_class_entry *zend_resolve_compile_time_parent(const zend_class } /* }}} */ +/* FE_FETCH_R dereferences array elements, while array_map() preserves references + * when passing them to callbacks. Only inline a callback whose mapped argument + * is known at compile time to be passed by value. */ +static bool zend_array_map_callback_takes_value(zend_ast *callback, uint32_t arg_num, zend_string *arg_name) +{ + zend_ast *name_ast = callback->child[callback->kind == ZEND_AST_CALL ? 0 : 1]; + if (name_ast->kind != ZEND_AST_ZVAL || Z_TYPE_P(zend_ast_get_zval(name_ast)) != IS_STRING) { + return false; + } + + const zend_function *fbc = NULL; + if (callback->kind == ZEND_AST_CALL) { + bool is_fully_qualified; + zend_string *resolved = zend_resolve_function_name( + zend_ast_get_str(name_ast), name_ast->attr, &is_fully_qualified); + zend_string *lcname = zend_string_tolower(resolved); + fbc = zend_hash_find_ptr(CG(function_table), lcname); + zend_string_release_ex(lcname, 0); + zend_string_release_ex(resolved, 0); + if (fbc && zend_compile_ignore_function(fbc, CG(active_op_array)->filename)) { + return false; + } + } else { + zend_ast *class_ast = callback->child[0]; + if (class_ast->kind != ZEND_AST_ZVAL + || Z_TYPE_P(zend_ast_get_zval(class_ast)) != IS_STRING) { + return false; + } + + const zend_class_entry *ce = NULL; + uint32_t fetch_type = zend_get_class_fetch_type(zend_ast_get_str(class_ast)); + if (fetch_type == ZEND_FETCH_CLASS_DEFAULT) { + zend_string *class_name = zend_resolve_class_name_ast(class_ast); + zend_string *lcname = zend_string_tolower(class_name); + ce = zend_hash_find_ptr(CG(class_table), lcname); + zend_string_release_ex(lcname, 0); + if (!ce && CG(active_class_entry) + && zend_string_equals_ci(CG(active_class_entry)->name, class_name)) { + ce = CG(active_class_entry); + } + zend_string_release_ex(class_name, 0); + } else if (fetch_type == ZEND_FETCH_CLASS_SELF && zend_is_scope_known()) { + ce = CG(active_class_entry); + } else if (fetch_type == ZEND_FETCH_CLASS_PARENT && zend_is_scope_known()) { + ce = zend_resolve_compile_time_parent(CG(active_class_entry)); + } + + if (!ce) { + return false; + } + zend_string *lcname = zend_string_tolower(zend_ast_get_str(name_ast)); + for (const zend_class_entry *cur_ce = ce; cur_ce && !fbc; cur_ce = zend_resolve_compile_time_parent(cur_ce)) { + if (!zend_compile_ignore_class(cur_ce, CG(active_op_array)->filename)) { + fbc = zend_get_compatible_func_or_null(cur_ce, lcname); + } + } + zend_string_release_ex(lcname, 0); + } + + if (!fbc || !fbc_is_finalized(fbc) || (fbc->common.fn_flags2 & ZEND_ACC2_FORBID_DYN_CALLS)) { + return false; + } + if (arg_name) { + arg_num = zend_get_arg_num(fbc, arg_name); + } + return arg_num != (uint32_t) -1 && !ARG_SHOULD_BE_SENT_BY_REF(fbc, arg_num); +} + static zend_result zend_compile_func_array_map(znode *result, zend_ast_list *args, zend_string *lcname, uint32_t lineno, uint32_t type) /* {{{ */ { /* array_map() as an internal function calls the callback as if strict_types=0, @@ -5391,9 +5459,14 @@ static zend_result zend_compile_func_array_map(znode *result, zend_ast_list *arg zend_ast_list *fcc_args = zend_ast_get_list(fcc->args); bool uses_named_args = false; bool has_placeholder = false; + uint32_t mapped_arg_num = 0; + zend_string *mapped_arg_name = NULL; for (uint32_t i = 0; i < fcc_args->children; i++) { zend_ast *arg = fcc_args->child[i]; if (arg->kind == ZEND_AST_NAMED_ARG) { + if (arg->child[1]->kind == ZEND_AST_PLACEHOLDER_ARG) { + mapped_arg_name = zend_ast_get_str(arg->child[0]); + } uses_named_args = true; arg = arg->child[1]; } @@ -5406,6 +5479,7 @@ static zend_result zend_compile_func_array_map(znode *result, zend_ast_list *arg return FAILURE; } has_placeholder = true; + mapped_arg_num = i + 1; continue; } @@ -5414,7 +5488,7 @@ static zend_result zend_compile_func_array_map(znode *result, zend_ast_list *arg } } - if (!has_placeholder) { + if (!has_placeholder || !zend_array_map_callback_takes_value(callback, mapped_arg_num, mapped_arg_name)) { return FAILURE; } From 449f8d9e590f0adf320201b782d5076f6fd33611 Mon Sep 17 00:00:00 2001 From: Pratik Bhujel Date: Thu, 19 Nov 2026 22:33:53 +0545 Subject: [PATCH 3/6] Keep array_map reference fix focused and update fallback opcode tests --- Zend/Optimizer/compact_literals.c | 1 - Zend/Optimizer/optimize_func_calls.c | 11 +- Zend/zend_compile.c | 13 - Zend/zend_vm_def.h | 20 +- Zend/zend_vm_execute.h | 1019 ++++------- Zend/zend_vm_handlers.h | 1507 ++++++++--------- Zend/zend_vm_opcodes.c | 2 +- .../array_map_foreach_optimization_006.phpt | 47 +- .../array_map_foreach_optimization_012.phpt | 145 +- .../array_map_foreach_optimization_014.phpt | 46 +- 10 files changed, 1097 insertions(+), 1714 deletions(-) diff --git a/Zend/Optimizer/compact_literals.c b/Zend/Optimizer/compact_literals.c index bc14d03cb671..6ed7e870da61 100644 --- a/Zend/Optimizer/compact_literals.c +++ b/Zend/Optimizer/compact_literals.c @@ -749,7 +749,6 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx case ZEND_SEND_VAR_NO_REF_EX: case ZEND_SEND_REF: case ZEND_SEND_FUNC_ARG: - case ZEND_SEND_USER: case ZEND_SEND_PLACEHOLDER: case ZEND_CHECK_FUNC_ARG: if (opline->op2_type == IS_CONST) { diff --git a/Zend/Optimizer/optimize_func_calls.c b/Zend/Optimizer/optimize_func_calls.c index 129c62230c80..4275bdb4071c 100644 --- a/Zend/Optimizer/optimize_func_calls.c +++ b/Zend/Optimizer/optimize_func_calls.c @@ -356,17 +356,8 @@ void zend_optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx) break; } break; - case ZEND_SEND_USER: - if (opline->op2_type != IS_CONST - && (opline->op1_type & (IS_CONST|IS_TMP_VAR)) - && has_known_send_mode(&call_stack[call - 1], opline->op2.num) - && !ARG_MUST_BE_SENT_BY_REF(call_stack[call - 1].func, opline->op2.num)) { - opline->opcode = ZEND_SEND_VAL; - break; - } - call_stack[call - 1].try_inline = false; - break; case ZEND_SEND_UNPACK: + case ZEND_SEND_USER: case ZEND_SEND_ARRAY: call_stack[call - 1].try_inline = false; break; diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 78790b088ad1..2b446acda295 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -5714,7 +5714,6 @@ static zend_result zend_compile_func_array_map(znode *result, zend_ast_list *arg zend_emit_op_tmp(©_node, ZEND_COPY_TMP, &func_node, NULL); func_ast = zend_ast_create_znode(©_node); } - uint32_t opnum_call_start = get_next_op_number(); switch (callback->kind) { case ZEND_AST_CALL: { zend_compile_expr(&call_result, zend_ast_create(ZEND_AST_CALL, func_ast, call_args)); @@ -5735,18 +5734,6 @@ static zend_result zend_compile_func_array_map(znode *result, zend_ast_list *arg break; } } - /* Pass the element with ZEND_SEND_USER semantics when the callee's send mode - * is not statically known by-value, so by-ref parameters warn and wrap instead - * of throwing Error. */ - for (uint32_t i = opnum_call_start; i < get_next_op_number(); i++) { - zend_op *op = &CG(active_op_array)->opcodes[i]; - if (op->opcode == ZEND_SEND_VAL_EX - && op->op1_type == IS_TMP_VAR - && op->op1.var == value.u.op.var) { - op->opcode = ZEND_SEND_USER; - break; - } - } if (func_ast != func_name_ast) { zend_ast_destroy(func_ast); } diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 9e9cc00b6a59..d10c891a730f 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -5670,29 +5670,17 @@ ZEND_VM_C_LABEL(send_array): ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -ZEND_VM_HANDLER(120, ZEND_SEND_USER, CONST|TMP|CV, CONST|UNUSED|NUM) +ZEND_VM_HANDLER(120, ZEND_SEND_USER, CONST|TMP|CV, NUM) { USE_OPLINE zval *arg, *param; - uint32_t arg_num; SAVE_OPLINE(); - if (OP2_TYPE == IS_CONST) { - zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); - if (UNEXPECTED(!param)) { - FREE_OP1(); - HANDLE_EXCEPTION(); - } - } else { - param = ZEND_CALL_VAR(EX(call), opline->result.var); - arg_num = opline->op2.num; - } - arg = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R); - if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { - zend_param_must_be_ref(EX(call)->func, arg_num); + param = ZEND_CALL_VAR(EX(call), opline->result.var); + if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { + zend_param_must_be_ref(EX(call)->func, opline->op2.num); Z_TRY_ADDREF_P(arg); ZVAL_NEW_REF(param, arg); } else { diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 94b1060d8d9a..8679330b2d0a 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -5237,6 +5237,27 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CATCH_SPEC_CO ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_USER_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *arg, *param; + + SAVE_OPLINE(); + + arg = RT_CONSTANT(opline, opline->op1); + param = ZEND_CALL_VAR(EX(call), opline->result.var); + if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { + zend_param_must_be_ref(EX(call)->func, opline->op2.num); + Z_TRY_ADDREF_P(arg); + ZVAL_NEW_REF(param, arg); + } else { + ZVAL_COPY(param, arg); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -7798,40 +7819,6 @@ send_val_by_ref:; ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_USER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *arg, *param; - uint32_t arg_num; - - SAVE_OPLINE(); - - if (IS_CONST == IS_CONST) { - zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); - if (UNEXPECTED(!param)) { - - - HANDLE_EXCEPTION(); - } - } else { - param = ZEND_CALL_VAR(EX(call), opline->result.var); - arg_num = opline->op2.num; - } - - arg = RT_CONSTANT(opline, opline->op1); - if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { - zend_param_must_be_ref(EX(call)->func, arg_num); - Z_TRY_ADDREF_P(arg); - ZVAL_NEW_REF(param, arg); - } else { - ZVAL_COPY(param, arg); - } - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { zend_class_entry *ce, *scope; @@ -11434,40 +11421,6 @@ send_val_by_ref:; ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_USER_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *arg, *param; - uint32_t arg_num; - - SAVE_OPLINE(); - - if (IS_UNUSED == IS_CONST) { - zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); - if (UNEXPECTED(!param)) { - - - HANDLE_EXCEPTION(); - } - } else { - param = ZEND_CALL_VAR(EX(call), opline->result.var); - arg_num = opline->op2.num; - } - - arg = RT_CONSTANT(opline, opline->op1); - if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { - zend_param_must_be_ref(EX(call)->func, arg_num); - Z_TRY_ADDREF_P(arg); - ZVAL_NEW_REF(param, arg); - } else { - ZVAL_COPY(param, arg); - } - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -17488,6 +17441,27 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_THROW_SPEC_TM HANDLE_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *arg, *param; + + SAVE_OPLINE(); + + arg = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + param = ZEND_CALL_VAR(EX(call), opline->result.var); + if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { + zend_param_must_be_ref(EX(call)->func, opline->op2.num); + Z_TRY_ADDREF_P(arg); + ZVAL_NEW_REF(param, arg); + } else { + ZVAL_COPY(param, arg); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_BOOL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -19427,39 +19401,6 @@ send_val_by_ref:; ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_USER_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *arg, *param; - uint32_t arg_num; - - SAVE_OPLINE(); - - if (IS_CONST == IS_CONST) { - zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); - if (UNEXPECTED(!param)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } - } else { - param = ZEND_CALL_VAR(EX(call), opline->result.var); - arg_num = opline->op2.num; - } - - arg = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { - zend_param_must_be_ref(EX(call)->func, arg_num); - Z_TRY_ADDREF_P(arg); - ZVAL_NEW_REF(param, arg); - } else { - ZVAL_COPY(param, arg); - } - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CASE_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -21814,39 +21755,6 @@ send_val_by_ref:; ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_USER_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *arg, *param; - uint32_t arg_num; - - SAVE_OPLINE(); - - if (IS_UNUSED == IS_CONST) { - zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); - if (UNEXPECTED(!param)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } - } else { - param = ZEND_CALL_VAR(EX(call), opline->result.var); - arg_num = opline->op2.num; - } - - arg = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { - zend_param_must_be_ref(EX(call)->func, arg_num); - Z_TRY_ADDREF_P(arg); - ZVAL_NEW_REF(param, arg); - } else { - ZVAL_COPY(param, arg); - } - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -40314,6 +40222,27 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_THROW_SPEC_CV HANDLE_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *arg, *param; + + SAVE_OPLINE(); + + arg = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); + param = ZEND_CALL_VAR(EX(call), opline->result.var); + if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { + zend_param_must_be_ref(EX(call)->func, opline->op2.num); + Z_TRY_ADDREF_P(arg); + ZVAL_NEW_REF(param, arg); + } else { + ZVAL_COPY(param, arg); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -44345,40 +44274,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_VAR_EX_S ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_USER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *arg, *param; - uint32_t arg_num; - - SAVE_OPLINE(); - - if (IS_CONST == IS_CONST) { - zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); - if (UNEXPECTED(!param)) { - - - HANDLE_EXCEPTION(); - } - } else { - param = ZEND_CALL_VAR(EX(call), opline->result.var); - arg_num = opline->op2.num; - } - - arg = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); - if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { - zend_param_must_be_ref(EX(call)->func, arg_num); - Z_TRY_ADDREF_P(arg); - ZVAL_NEW_REF(param, arg); - } else { - ZVAL_COPY(param, arg); - } - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -49750,40 +49645,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_S ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_USER_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *arg, *param; - uint32_t arg_num; - - SAVE_OPLINE(); - - if (IS_UNUSED == IS_CONST) { - zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); - if (UNEXPECTED(!param)) { - - - HANDLE_EXCEPTION(); - } - } else { - param = ZEND_CALL_VAR(EX(call), opline->result.var); - arg_num = opline->op2.num; - } - - arg = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); - if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { - zend_param_must_be_ref(EX(call)->func, arg_num); - Z_TRY_ADDREF_P(arg); - ZVAL_NEW_REF(param, arg); - } else { - ZVAL_COPY(param, arg); - } - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -58271,6 +58132,27 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CATCH_SPEC_CONST_T ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_USER_SPEC_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *arg, *param; + + SAVE_OPLINE(); + + arg = RT_CONSTANT(opline, opline->op1); + param = ZEND_CALL_VAR(EX(call), opline->result.var); + if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { + zend_param_must_be_ref(EX(call)->func, opline->op2.num); + Z_TRY_ADDREF_P(arg); + ZVAL_NEW_REF(param, arg); + } else { + ZVAL_COPY(param, arg); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_BOOL_SPEC_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -60832,40 +60714,6 @@ send_val_by_ref:; ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_USER_SPEC_CONST_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *arg, *param; - uint32_t arg_num; - - SAVE_OPLINE(); - - if (IS_CONST == IS_CONST) { - zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); - if (UNEXPECTED(!param)) { - - - HANDLE_EXCEPTION(); - } - } else { - param = ZEND_CALL_VAR(EX(call), opline->result.var); - arg_num = opline->op2.num; - } - - arg = RT_CONSTANT(opline, opline->op1); - if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { - zend_param_must_be_ref(EX(call)->func, arg_num); - Z_TRY_ADDREF_P(arg); - ZVAL_NEW_REF(param, arg); - } else { - ZVAL_COPY(param, arg); - } - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { zend_class_entry *ce, *scope; @@ -64366,40 +64214,6 @@ send_val_by_ref:; ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_USER_SPEC_CONST_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *arg, *param; - uint32_t arg_num; - - SAVE_OPLINE(); - - if (IS_UNUSED == IS_CONST) { - zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); - if (UNEXPECTED(!param)) { - - - HANDLE_EXCEPTION(); - } - } else { - param = ZEND_CALL_VAR(EX(call), opline->result.var); - arg_num = opline->op2.num; - } - - arg = RT_CONSTANT(opline, opline->op1); - if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { - zend_param_must_be_ref(EX(call)->func, arg_num); - Z_TRY_ADDREF_P(arg); - ZVAL_NEW_REF(param, arg); - } else { - ZVAL_COPY(param, arg); - } - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_NEW_SPEC_CONST_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -70420,6 +70234,27 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_THROW_SPEC_TMP_TAI HANDLE_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_USER_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *arg, *param; + + SAVE_OPLINE(); + + arg = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + param = ZEND_CALL_VAR(EX(call), opline->result.var); + if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { + zend_param_must_be_ref(EX(call)->func, opline->op2.num); + Z_TRY_ADDREF_P(arg); + ZVAL_NEW_REF(param, arg); + } else { + ZVAL_COPY(param, arg); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_BOOL_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -72359,39 +72194,6 @@ send_val_by_ref:; ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_USER_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *arg, *param; - uint32_t arg_num; - - SAVE_OPLINE(); - - if (IS_CONST == IS_CONST) { - zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); - if (UNEXPECTED(!param)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } - } else { - param = ZEND_CALL_VAR(EX(call), opline->result.var); - arg_num = opline->op2.num; - } - - arg = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { - zend_param_must_be_ref(EX(call)->func, arg_num); - Z_TRY_ADDREF_P(arg); - ZVAL_NEW_REF(param, arg); - } else { - ZVAL_COPY(param, arg); - } - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CASE_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -74646,39 +74448,6 @@ send_val_by_ref:; ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_USER_SPEC_TMP_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *arg, *param; - uint32_t arg_num; - - SAVE_OPLINE(); - - if (IS_UNUSED == IS_CONST) { - zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); - if (UNEXPECTED(!param)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } - } else { - param = ZEND_CALL_VAR(EX(call), opline->result.var); - arg_num = opline->op2.num; - } - - arg = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { - zend_param_must_be_ref(EX(call)->func, arg_num); - Z_TRY_ADDREF_P(arg); - ZVAL_NEW_REF(param, arg); - } else { - ZVAL_COPY(param, arg); - } - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -93146,6 +92915,27 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_THROW_SPEC_CV_TAIL HANDLE_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_USER_SPEC_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *arg, *param; + + SAVE_OPLINE(); + + arg = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); + param = ZEND_CALL_VAR(EX(call), opline->result.var); + if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { + zend_param_must_be_ref(EX(call)->func, opline->op2.num); + Z_TRY_ADDREF_P(arg); + ZVAL_NEW_REF(param, arg); + } else { + ZVAL_COPY(param, arg); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_BOOL_SPEC_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -97177,40 +96967,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_VAR_EX_SPEC_C ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_USER_SPEC_CV_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *arg, *param; - uint32_t arg_num; - - SAVE_OPLINE(); - - if (IS_CONST == IS_CONST) { - zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); - if (UNEXPECTED(!param)) { - - - HANDLE_EXCEPTION(); - } - } else { - param = ZEND_CALL_VAR(EX(call), opline->result.var); - arg_num = opline->op2.num; - } - - arg = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); - if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { - zend_param_must_be_ref(EX(call)->func, arg_num); - Z_TRY_ADDREF_P(arg); - ZVAL_NEW_REF(param, arg); - } else { - ZVAL_COPY(param, arg); - } - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -102480,40 +102236,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_V ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_USER_SPEC_CV_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *arg, *param; - uint32_t arg_num; - - SAVE_OPLINE(); - - if (IS_UNUSED == IS_CONST) { - zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - param = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); - if (UNEXPECTED(!param)) { - - - HANDLE_EXCEPTION(); - } - } else { - param = ZEND_CALL_VAR(EX(call), opline->result.var); - arg_num = opline->op2.num; - } - - arg = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); - if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num))) { - zend_param_must_be_ref(EX(call)->func, arg_num); - Z_TRY_ADDREF_P(arg); - ZVAL_NEW_REF(param, arg); - } else { - ZVAL_COPY(param, arg); - } - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -109560,31 +109282,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CV_LABEL, (void*)&&ZEND_SEND_ARRAY_SPEC_LABEL, - (void*)&&ZEND_SEND_USER_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_SEND_USER_SPEC_CONST_UNUSED_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_SEND_USER_SPEC_TMP_CONST_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_SEND_USER_SPEC_TMP_UNUSED_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_USER_SPEC_CONST_LABEL, + (void*)&&ZEND_SEND_USER_SPEC_TMP_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_SEND_USER_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_SEND_USER_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_USER_SPEC_CV_LABEL, (void*)&&ZEND_STRLEN_SPEC_CONST_LABEL, (void*)&&ZEND_STRLEN_SPEC_TMP_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -111659,6 +111361,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_CATCH_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_CATCH_SPEC_CONST) HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_USER_SPEC_CONST): + VM_TRACE(ZEND_SEND_USER_SPEC_CONST) + ZEND_SEND_USER_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_CONST) + HYBRID_BREAK(); HYBRID_CASE(ZEND_BOOL_SPEC_CONST): VM_TRACE(ZEND_BOOL_SPEC_CONST) ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -111934,11 +111641,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_CONST_CONST) HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_USER_SPEC_CONST_CONST): - VM_TRACE(ZEND_SEND_USER_SPEC_CONST_CONST) - ZEND_SEND_USER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_CONST_CONST) - HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST): VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -112319,11 +112021,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK) HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_USER_SPEC_CONST_UNUSED): - VM_TRACE(ZEND_SEND_USER_SPEC_CONST_UNUSED) - ZEND_SEND_USER_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_CONST_UNUSED) - HYBRID_BREAK(); HYBRID_CASE(ZEND_NEW_SPEC_CONST_UNUSED): VM_TRACE(ZEND_NEW_SPEC_CONST_UNUSED) ZEND_NEW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -113288,6 +112985,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_THROW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_THROW_SPEC_TMP) HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_USER_SPEC_TMP): + VM_TRACE(ZEND_SEND_USER_SPEC_TMP) + ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_TMP) + HYBRID_BREAK(); HYBRID_CASE(ZEND_BOOL_SPEC_TMP): VM_TRACE(ZEND_BOOL_SPEC_TMP) ZEND_BOOL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -113473,11 +113175,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_TMP_CONST) HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_USER_SPEC_TMP_CONST): - VM_TRACE(ZEND_SEND_USER_SPEC_TMP_CONST) - ZEND_SEND_USER_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_TMP_CONST) - HYBRID_BREAK(); HYBRID_CASE(ZEND_CASE_SPEC_TMP_CONST): VM_TRACE(ZEND_CASE_SPEC_TMP_CONST) ZEND_CASE_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -113713,11 +113410,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK) HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_USER_SPEC_TMP_UNUSED): - VM_TRACE(ZEND_SEND_USER_SPEC_TMP_UNUSED) - ZEND_SEND_USER_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_TMP_UNUSED) - HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED) ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -115182,6 +114874,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_THROW_SPEC_CV) HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_USER_SPEC_CV): + VM_TRACE(ZEND_SEND_USER_SPEC_CV) + ZEND_SEND_USER_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_CV) + HYBRID_BREAK(); HYBRID_CASE(ZEND_BOOL_SPEC_CV): VM_TRACE(ZEND_BOOL_SPEC_CV) ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -115552,11 +115249,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_SEND_VAR_EX_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_CV_CONST) HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_USER_SPEC_CV_CONST): - VM_TRACE(ZEND_SEND_USER_SPEC_CV_CONST) - ZEND_SEND_USER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_CV_CONST) - HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST) ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -115982,11 +115674,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK) HYBRID_BREAK(); - HYBRID_CASE(ZEND_SEND_USER_SPEC_CV_UNUSED): - VM_TRACE(ZEND_SEND_USER_SPEC_CV_UNUSED) - ZEND_SEND_USER_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_CV_UNUSED) - HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED) ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -118563,31 +118250,11 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER, ZEND_SEND_ARRAY_SPEC_HANDLER, - ZEND_SEND_USER_SPEC_CONST_CONST_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_SEND_USER_SPEC_CONST_UNUSED_HANDLER, - ZEND_NULL_HANDLER, - ZEND_SEND_USER_SPEC_TMP_CONST_HANDLER, - ZEND_NULL_HANDLER, + ZEND_SEND_USER_SPEC_CONST_HANDLER, + ZEND_SEND_USER_SPEC_TMP_HANDLER, ZEND_NULL_HANDLER, - ZEND_SEND_USER_SPEC_TMP_UNUSED_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_SEND_USER_SPEC_CV_CONST_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_SEND_USER_SPEC_CV_UNUSED_HANDLER, ZEND_NULL_HANDLER, + ZEND_SEND_USER_SPEC_CV_HANDLER, ZEND_STRLEN_SPEC_CONST_HANDLER, ZEND_STRLEN_SPEC_TMP_HANDLER, ZEND_NULL_HANDLER, @@ -122071,31 +121738,11 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_INIT_USER_CALL_SPEC_CONST_CV_TAILCALL_HANDLER, ZEND_SEND_ARRAY_SPEC_TAILCALL_HANDLER, - ZEND_SEND_USER_SPEC_CONST_CONST_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_SEND_USER_SPEC_CONST_UNUSED_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_SEND_USER_SPEC_TMP_CONST_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_SEND_USER_SPEC_TMP_UNUSED_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_SEND_USER_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_SEND_USER_SPEC_CONST_TAILCALL_HANDLER, + ZEND_SEND_USER_SPEC_TMP_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, - ZEND_SEND_USER_SPEC_CV_UNUSED_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_SEND_USER_SPEC_CV_TAILCALL_HANDLER, ZEND_STRLEN_SPEC_CONST_TAILCALL_HANDLER, ZEND_STRLEN_SPEC_TMP_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -123475,7 +123122,7 @@ void zend_vm_init(void) 1255, 1256 | SPEC_RULE_OP1, 1261 | SPEC_RULE_OP1, - 3504, + 3484, 1266 | SPEC_RULE_OP1, 1271 | SPEC_RULE_OP1, 1276 | SPEC_RULE_OP2, @@ -123509,7 +123156,7 @@ void zend_vm_init(void) 1559 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 1584 | SPEC_RULE_OP1, 1589, - 3504, + 3484, 1590 | SPEC_RULE_OP1, 1595 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 1620 | SPEC_RULE_OP1 | SPEC_RULE_OP2, @@ -123550,142 +123197,142 @@ void zend_vm_init(void) 2122 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 2147 | SPEC_RULE_OP2, 2152, - 2153 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2178 | SPEC_RULE_OP1, - 2183, - 2184 | SPEC_RULE_OP1, - 2189 | SPEC_RULE_OP1, - 2194 | SPEC_RULE_OP1, - 2199, - 2200, - 2201 | SPEC_RULE_OP2, - 2206 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, - 2210 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, - 2214 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, - 2218 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2218 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2243 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2243 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2268 | SPEC_RULE_OP1, - 2273, - 2274 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2299, - 2300 | SPEC_RULE_OP1, - 2305, - 2306, - 2307, - 2308, - 2309, - 2310, - 2311, - 2312 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2337, - 2338, - 2339, - 2340 | SPEC_RULE_OP1, - 2345, - 2346 | SPEC_RULE_ISSET, - 2348 | SPEC_RULE_OP2, - 2353, - 2354 | SPEC_RULE_OP1, - 2359 | SPEC_RULE_OBSERVER, - 2361, - 2362 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2387 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, - 2397, - 2398, - 2399, - 2400, - 2401 | SPEC_RULE_OP1, - 2406, - 2407, - 2408 | SPEC_RULE_OP1, - 2413 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2438, - 2439 | SPEC_RULE_OP1, - 2444, - 2445, - 2446, - 2447, - 2448, - 2449, - 2450, - 2451, - 2452 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2477, - 2478, - 2479, - 2480 | SPEC_RULE_OP2, - 2485, + 2153 | SPEC_RULE_OP1, + 2158 | SPEC_RULE_OP1, + 2163, + 2164 | SPEC_RULE_OP1, + 2169 | SPEC_RULE_OP1, + 2174 | SPEC_RULE_OP1, + 2179, + 2180, + 2181 | SPEC_RULE_OP2, + 2186 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 2190 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 2194 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 2198 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2198 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2223 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2223 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2248 | SPEC_RULE_OP1, + 2253, + 2254 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2279, + 2280 | SPEC_RULE_OP1, + 2285, + 2286, + 2287, + 2288, + 2289, + 2290, + 2291, + 2292 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2317, + 2318, + 2319, + 2320 | SPEC_RULE_OP1, + 2325, + 2326 | SPEC_RULE_ISSET, + 2328 | SPEC_RULE_OP2, + 2333, + 2334 | SPEC_RULE_OP1, + 2339 | SPEC_RULE_OBSERVER, + 2341, + 2342 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2367 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 2377, + 2378, + 2379, + 2380, + 2381 | SPEC_RULE_OP1, + 2386, + 2387, + 2388 | SPEC_RULE_OP1, + 2393 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2418, + 2419 | SPEC_RULE_OP1, + 2424, + 2425, + 2426, + 2427, + 2428, + 2429, + 2430, + 2431, + 2432 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2457, + 2458, + 2459, + 2460 | SPEC_RULE_OP2, + 2465, + 2466 | SPEC_RULE_OP1, + 2471 | SPEC_RULE_OP1, + 2476 | SPEC_RULE_OP1, + 2481 | SPEC_RULE_OP1, 2486 | SPEC_RULE_OP1, - 2491 | SPEC_RULE_OP1, - 2496 | SPEC_RULE_OP1, - 2501 | SPEC_RULE_OP1, - 2506 | SPEC_RULE_OP1, - 2511, - 2512 | SPEC_RULE_OP1, - 2517 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2542 | SPEC_RULE_OP1, - 2547 | SPEC_RULE_OP2, - 2552 | SPEC_RULE_OP1, - 2557 | SPEC_RULE_OP1, - 2562, - 2563, - 2564, - 2565, - 2566, - 2567 | SPEC_RULE_OBSERVER, - 2569 | SPEC_RULE_OBSERVER, - 2571 | SPEC_RULE_OBSERVER, - 2573 | SPEC_RULE_OBSERVER, - 2575, - 2576, - 2577, - 2578, - 2579 | SPEC_RULE_OP2, - 2584 | SPEC_RULE_OP2, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, - 3504, + 2491, + 2492 | SPEC_RULE_OP1, + 2497 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2522 | SPEC_RULE_OP1, + 2527 | SPEC_RULE_OP2, + 2532 | SPEC_RULE_OP1, + 2537 | SPEC_RULE_OP1, + 2542, + 2543, + 2544, + 2545, + 2546, + 2547 | SPEC_RULE_OBSERVER, + 2549 | SPEC_RULE_OBSERVER, + 2551 | SPEC_RULE_OBSERVER, + 2553 | SPEC_RULE_OBSERVER, + 2555, + 2556, + 2557, + 2558, + 2559 | SPEC_RULE_OP2, + 2564 | SPEC_RULE_OP2, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, + 3484, }; #if 0 #elif (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) @@ -123878,7 +123525,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 = 2597 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2577 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -123886,7 +123533,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 = 2622 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2602 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -123894,7 +123541,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 = 2647 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2627 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -123905,17 +123552,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 = 2672 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2652 | 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 = 2697 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2677 | 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 = 2722 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2702 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -123926,17 +123573,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 = 2747 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2727 | 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 = 2772 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2752 | 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 = 2797 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2777 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -123947,19 +123594,19 @@ 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 = 2822 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2802 | 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 = 2897 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2877 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op2_type == IS_CONST && (Z_TYPE_P(RT_CONSTANT(op, op->op2)) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(RT_CONSTANT(op, op->op2))) == 0)) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3122 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3102 | 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)) && !((op1_info & op2_info) & MAY_BE_ARRAY_OF_ARRAY)) { - spec = 3128 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3108 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -123970,19 +123617,19 @@ 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 = 2972 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2952 | 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 = 3047 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3027 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op2_type == IS_CONST && (Z_TYPE_P(RT_CONSTANT(op, op->op2)) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(RT_CONSTANT(op, op->op2))) == 0)) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3125 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3105 | 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)) && !((op1_info & op2_info) & MAY_BE_ARRAY_OF_ARRAY)) { - spec = 3133 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3113 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -123993,12 +123640,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 = 2822 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2802 | 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 = 2897 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2877 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -124009,12 +123656,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 = 2972 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2952 | 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 = 3047 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3027 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -124022,12 +123669,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 = 3138 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3118 | 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 = 3213 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3193 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -124035,79 +123682,79 @@ 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 = 3288 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3268 | 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 = 3363 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3343 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3450 | SPEC_RULE_OP1; + spec = 3430 | SPEC_RULE_OP1; } else if (op1_info == MAY_BE_DOUBLE) { - spec = 3455 | SPEC_RULE_OP1; + spec = 3435 | 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 = 3460 | SPEC_RULE_OP1; + spec = 3440 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3438 | SPEC_RULE_RETVAL; + spec = 3418 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3440 | SPEC_RULE_RETVAL; + spec = 3420 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3442 | SPEC_RULE_RETVAL; + spec = 3422 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3444 | SPEC_RULE_RETVAL; + spec = 3424 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3446; + spec = 3426; } else if (op1_info == MAY_BE_LONG) { - spec = 3447; + spec = 3427; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3448; + spec = 3428; } else if (op1_info == MAY_BE_LONG) { - spec = 3449; + spec = 3429; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2596; + spec = 2576; } break; case ZEND_INIT_FCALL: if (Z_EXTRA_P(RT_CONSTANT(op, op->op2)) != 0) { - spec = 2589; + spec = 2569; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2590; + spec = 2570; } break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3500; + spec = 3480; } break; case ZEND_SEND_VAR_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3495 | SPEC_RULE_OP1; + spec = 3475 | SPEC_RULE_OP1; } break; case ZEND_FE_FETCH_R: if (op->op2_type == IS_CV && (op1_info & (MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 3502 | SPEC_RULE_RETVAL; + spec = 3482 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -124115,22 +123762,22 @@ 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 = 3465 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3445 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_SEND_VAL_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3501; + spec = 3481; } break; case ZEND_SEND_VAR: if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3490 | SPEC_RULE_OP1; + spec = 3470 | SPEC_RULE_OP1; } break; case ZEND_COUNT: if (op->op1_type != IS_CONST && (op1_info & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 2591 | SPEC_RULE_OP1; + spec = 2571 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 7ec616206964..4586fd861021 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -843,758 +843,755 @@ _(2148, ZEND_INIT_USER_CALL_SPEC_CONST_TMP) \ _(2151, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \ _(2152, ZEND_SEND_ARRAY_SPEC) \ - _(2153, ZEND_SEND_USER_SPEC_CONST_CONST) \ - _(2156, ZEND_SEND_USER_SPEC_CONST_UNUSED) \ - _(2158, ZEND_SEND_USER_SPEC_TMP_CONST) \ - _(2161, ZEND_SEND_USER_SPEC_TMP_UNUSED) \ - _(2173, ZEND_SEND_USER_SPEC_CV_CONST) \ - _(2176, ZEND_SEND_USER_SPEC_CV_UNUSED) \ - _(2178, ZEND_STRLEN_SPEC_CONST) \ - _(2179, ZEND_STRLEN_SPEC_TMP) \ - _(2182, ZEND_STRLEN_SPEC_CV) \ - _(2183, ZEND_DEFINED_SPEC_CONST) \ - _(2184, ZEND_TYPE_CHECK_SPEC_CONST) \ - _(2185, ZEND_TYPE_CHECK_SPEC_TMP) \ - _(2188, ZEND_TYPE_CHECK_SPEC_CV) \ - _(2189, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \ - _(2190, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \ - _(2191, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \ - _(2192, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \ - _(2193, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \ - _(2194, ZEND_FE_RESET_RW_SPEC_CONST) \ - _(2195, ZEND_FE_RESET_RW_SPEC_TMP) \ - _(2196, ZEND_FE_RESET_RW_SPEC_VAR) \ - _(2198, ZEND_FE_RESET_RW_SPEC_CV) \ - _(2199, ZEND_FE_FETCH_RW_SPEC_VAR) \ - _(2200, ZEND_FE_FREE_SPEC_TMPVAR) \ - _(2201, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \ - _(2202, ZEND_INIT_DYNAMIC_CALL_SPEC_TMP) \ - _(2205, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \ - _(2206, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \ - _(2207, ZEND_DO_ICALL_SPEC_RETVAL_USED) \ - _(2208, ZEND_DO_ICALL_SPEC_OBSERVER) \ - _(2209, ZEND_DO_ICALL_SPEC_OBSERVER) \ - _(2210, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \ - _(2211, ZEND_DO_UCALL_SPEC_RETVAL_USED) \ - _(2212, ZEND_DO_UCALL_SPEC_OBSERVER) \ - _(2213, ZEND_DO_UCALL_SPEC_OBSERVER) \ - _(2214, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \ - _(2215, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \ - _(2216, ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER) \ - _(2217, ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER) \ - _(2228, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \ - _(2229, ZEND_PRE_INC_OBJ_SPEC_VAR_TMP) \ - _(2232, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \ - _(2233, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \ - _(2234, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP) \ - _(2237, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \ - _(2238, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \ - _(2239, ZEND_PRE_INC_OBJ_SPEC_CV_TMP) \ - _(2242, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \ - _(2253, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \ - _(2254, ZEND_POST_INC_OBJ_SPEC_VAR_TMP) \ - _(2257, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \ - _(2258, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \ - _(2259, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP) \ - _(2262, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \ - _(2263, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \ - _(2264, ZEND_POST_INC_OBJ_SPEC_CV_TMP) \ - _(2267, ZEND_POST_INC_OBJ_SPEC_CV_CV) \ - _(2268, ZEND_ECHO_SPEC_CONST) \ - _(2269, ZEND_ECHO_SPEC_TMP) \ - _(2272, ZEND_ECHO_SPEC_CV) \ - _(2279, ZEND_INSTANCEOF_SPEC_TMP_CONST) \ - _(2281, ZEND_INSTANCEOF_SPEC_TMP_VAR) \ - _(2282, ZEND_INSTANCEOF_SPEC_TMP_UNUSED) \ - _(2294, ZEND_INSTANCEOF_SPEC_CV_CONST) \ - _(2296, ZEND_INSTANCEOF_SPEC_CV_VAR) \ - _(2297, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \ - _(2299, ZEND_GENERATOR_CREATE_SPEC) \ - _(2302, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \ - _(2304, ZEND_MAKE_REF_SPEC_CV_UNUSED) \ - _(2305, ZEND_DECLARE_FUNCTION_SPEC) \ - _(2306, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_UNUSED) \ - _(2307, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ - _(2308, ZEND_DECLARE_CLASS_SPEC_CONST) \ - _(2309, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \ - _(2310, ZEND_DECLARE_ANON_CLASS_SPEC) \ - _(2311, ZEND_ADD_ARRAY_UNPACK_SPEC) \ - _(2312, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ - _(2313, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMP) \ - _(2316, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ - _(2317, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CONST) \ - _(2318, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_TMP) \ - _(2321, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CV) \ - _(2327, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ - _(2328, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP) \ - _(2331, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ - _(2332, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ - _(2333, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP) \ - _(2336, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ - _(2337, ZEND_HANDLE_EXCEPTION_SPEC) \ - _(2338, ZEND_USER_OPCODE_SPEC) \ - _(2339, ZEND_ASSERT_CHECK_SPEC) \ - _(2340, ZEND_JMP_SET_SPEC_CONST) \ - _(2341, ZEND_JMP_SET_SPEC_TMP) \ - _(2344, ZEND_JMP_SET_SPEC_CV) \ - _(2345, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ - _(2346, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ - _(2347, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ - _(2348, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ - _(2349, ZEND_FETCH_LIST_W_SPEC_VAR_TMP) \ - _(2352, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ - _(2353, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ - _(2355, ZEND_FETCH_CLASS_NAME_SPEC_TMP) \ - _(2357, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ - _(2358, ZEND_FETCH_CLASS_NAME_SPEC_CV) \ - _(2359, ZEND_CALL_TRAMPOLINE_SPEC) \ - _(2360, ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER) \ - _(2361, ZEND_DISCARD_EXCEPTION_SPEC) \ - _(2362, ZEND_YIELD_SPEC_CONST_CONST) \ - _(2363, ZEND_YIELD_SPEC_CONST_TMP) \ - _(2365, ZEND_YIELD_SPEC_CONST_UNUSED) \ - _(2366, ZEND_YIELD_SPEC_CONST_CV) \ - _(2367, ZEND_YIELD_SPEC_TMP_CONST) \ - _(2368, ZEND_YIELD_SPEC_TMP_TMP) \ - _(2370, ZEND_YIELD_SPEC_TMP_UNUSED) \ - _(2371, ZEND_YIELD_SPEC_TMP_CV) \ - _(2372, ZEND_YIELD_SPEC_VAR_CONST) \ - _(2373, ZEND_YIELD_SPEC_VAR_TMP) \ - _(2375, ZEND_YIELD_SPEC_VAR_UNUSED) \ - _(2376, ZEND_YIELD_SPEC_VAR_CV) \ - _(2377, ZEND_YIELD_SPEC_UNUSED_CONST) \ - _(2378, ZEND_YIELD_SPEC_UNUSED_TMP) \ - _(2380, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ - _(2381, ZEND_YIELD_SPEC_UNUSED_CV) \ - _(2382, ZEND_YIELD_SPEC_CV_CONST) \ - _(2383, ZEND_YIELD_SPEC_CV_TMP) \ - _(2385, ZEND_YIELD_SPEC_CV_UNUSED) \ - _(2386, ZEND_YIELD_SPEC_CV_CV) \ - _(2387, ZEND_GENERATOR_RETURN_SPEC_CONST) \ - _(2388, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ - _(2389, ZEND_GENERATOR_RETURN_SPEC_TMP) \ - _(2390, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ - _(2391, ZEND_GENERATOR_RETURN_SPEC_VAR) \ - _(2392, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ - _(2395, ZEND_GENERATOR_RETURN_SPEC_CV) \ - _(2396, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ - _(2397, ZEND_FAST_CALL_SPEC) \ - _(2398, ZEND_FAST_RET_SPEC) \ - _(2399, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ - _(2400, ZEND_SEND_UNPACK_SPEC) \ - _(2401, ZEND_YIELD_FROM_SPEC_CONST) \ - _(2402, ZEND_YIELD_FROM_SPEC_TMP) \ - _(2405, ZEND_YIELD_FROM_SPEC_CV) \ - _(2406, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ - _(2407, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ - _(2408, ZEND_COALESCE_SPEC_CONST) \ - _(2409, ZEND_COALESCE_SPEC_TMP) \ - _(2412, ZEND_COALESCE_SPEC_CV) \ - _(2413, ZEND_SPACESHIP_SPEC_CONST_CONST) \ - _(2414, ZEND_SPACESHIP_SPEC_CONST_TMP) \ - _(2417, ZEND_SPACESHIP_SPEC_CONST_CV) \ - _(2418, ZEND_SPACESHIP_SPEC_TMP_CONST) \ - _(2419, ZEND_SPACESHIP_SPEC_TMP_TMP) \ - _(2422, ZEND_SPACESHIP_SPEC_TMP_CV) \ - _(2433, ZEND_SPACESHIP_SPEC_CV_CONST) \ - _(2434, ZEND_SPACESHIP_SPEC_CV_TMP) \ - _(2437, ZEND_SPACESHIP_SPEC_CV_CV) \ - _(2438, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ - _(2439, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ - _(2442, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ - _(2444, ZEND_FETCH_STATIC_PROP_R_SPEC) \ - _(2445, ZEND_FETCH_STATIC_PROP_W_SPEC) \ - _(2446, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ - _(2447, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ - _(2448, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ - _(2449, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ - _(2450, ZEND_UNSET_STATIC_PROP_SPEC) \ - _(2451, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ - _(2452, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ - _(2453, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ - _(2454, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ - _(2456, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ - _(2462, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ - _(2463, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ - _(2464, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ - _(2466, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ - _(2467, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ - _(2468, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ - _(2469, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ - _(2471, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ - _(2477, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ - _(2478, ZEND_BIND_STATIC_SPEC_CV) \ - _(2479, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ - _(2480, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \ - _(2483, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \ - _(2485, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ - _(2486, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ - _(2487, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2488, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2490, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2491, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ - _(2492, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2493, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2495, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2496, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ - _(2497, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ - _(2500, ZEND_IN_ARRAY_SPEC_CV_CONST) \ - _(2501, ZEND_COUNT_SPEC_CONST_UNUSED) \ - _(2502, ZEND_COUNT_SPEC_TMP_UNUSED) \ - _(2505, ZEND_COUNT_SPEC_CV_UNUSED) \ - _(2506, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ - _(2507, ZEND_GET_CLASS_SPEC_TMP_UNUSED) \ - _(2509, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ - _(2510, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ - _(2511, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ - _(2512, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ - _(2513, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ - _(2516, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ - _(2517, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ - _(2518, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMP) \ - _(2521, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ - _(2522, ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CONST) \ - _(2523, ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_TMP) \ - _(2526, ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CV) \ - _(2537, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ - _(2538, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMP) \ - _(2541, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ - _(2542, ZEND_MATCH_SPEC_CONST_CONST) \ - _(2543, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2544, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2546, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2547, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ - _(2548, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ - _(2551, ZEND_CASE_STRICT_SPEC_TMP_CV) \ - _(2552, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ - _(2553, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2554, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2556, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2557, ZEND_JMP_NULL_SPEC_CONST) \ - _(2558, ZEND_JMP_NULL_SPEC_TMP) \ - _(2561, ZEND_JMP_NULL_SPEC_CV) \ - _(2562, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ - _(2563, ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED) \ - _(2564, ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED) \ - _(2565, ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED) \ - _(2566, ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV) \ - _(2567, ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED) \ - _(2568, ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER) \ - _(2569, ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED) \ - _(2570, ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER) \ - _(2571, ZEND_FRAMELESS_ICALL_2_SPEC) \ - _(2572, ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER) \ - _(2573, ZEND_FRAMELESS_ICALL_3_SPEC) \ - _(2574, ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER) \ - _(2575, ZEND_JMP_FRAMELESS_SPEC_CONST) \ - _(2576, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED) \ - _(2577, ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST) \ - _(2578, ZEND_TYPE_ASSERT_SPEC_CONST) \ - _(2579, ZEND_CALLABLE_CONVERT_PARTIAL_SPEC_CONST_CONST) \ - _(2582, ZEND_CALLABLE_CONVERT_PARTIAL_SPEC_CONST_UNUSED) \ - _(2584, ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_CONST) \ - _(2587, ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_UNUSED) \ - _(2589, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \ - _(2590, ZEND_RECV_NOTYPE_SPEC) \ - _(2592, ZEND_COUNT_ARRAY_SPEC_TMP_UNUSED) \ - _(2595, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \ - _(2596, ZEND_JMP_FORWARD_SPEC) \ - _(2602, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2603, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2604, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2606, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2607, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2608, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2609, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2611, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2617, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2618, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2619, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2621, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2627, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2628, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2629, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2631, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2632, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2633, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2634, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2636, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2642, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2643, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2644, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2646, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2652, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2653, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2654, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2656, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2657, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2658, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2659, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2661, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2667, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2668, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2669, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2671, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2673, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2674, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2676, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2677, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2678, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2679, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2681, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2682, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2683, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2684, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2686, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2692, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2693, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2694, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2696, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2698, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2699, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2701, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2702, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2703, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2704, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2706, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2707, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2708, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2709, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2711, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2717, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2718, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2719, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2721, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2723, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2724, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2726, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2727, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2728, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2729, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2731, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2732, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2733, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2734, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2736, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2742, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2743, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2744, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2746, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2752, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2753, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2754, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2756, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2757, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2758, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2759, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2761, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2767, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2768, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2769, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2771, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2777, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2778, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2779, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2781, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2782, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2783, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2784, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2786, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2792, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2793, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2794, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2796, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2802, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2803, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2804, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2806, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2807, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2808, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2809, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2811, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2817, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2818, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2819, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2821, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2845, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2849, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2850, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2851, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2852, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2853, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2854, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2855, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2856, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2857, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2858, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2859, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2860, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2864, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2865, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2866, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2882, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2883, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2884, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2885, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2886, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2887, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2888, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2889, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2890, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2894, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2895, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2896, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2920, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2924, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2925, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2926, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2927, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2928, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2929, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2930, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2931, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2932, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2933, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2934, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2935, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2939, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2940, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2941, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2957, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2958, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2959, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2960, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2961, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2962, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2963, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2964, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2965, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2969, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2970, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2971, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2999, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3000, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3001, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3002, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3003, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3004, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3005, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3006, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3007, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3008, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3009, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3010, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3014, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3015, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3016, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3032, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3033, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3034, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3035, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3036, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3037, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3038, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3039, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3040, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3044, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3045, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3046, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3074, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3075, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3076, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3077, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3078, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3079, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3080, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3081, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3082, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3083, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3084, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3085, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3089, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3090, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3091, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3107, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3108, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3109, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3110, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3111, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3112, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3113, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3114, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3115, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3119, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3120, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3121, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3122, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ - _(3123, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3124, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3125, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ - _(3126, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3127, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3128, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3132, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3133, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3137, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3141, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3142, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3143, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3144, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3145, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3146, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3150, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3151, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3152, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3153, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3154, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3158, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3159, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3160, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3161, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3165, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3166, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3167, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3168, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3169, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3170, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3171, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3172, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3173, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3174, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3175, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3176, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3180, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3181, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3182, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3198, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3199, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3200, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3201, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3202, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3203, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3204, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3205, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3206, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3210, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3211, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3212, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3217, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3233, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3234, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3235, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3236, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3240, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3241, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3242, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3243, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3244, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3245, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3246, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3247, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3248, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3249, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3250, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3251, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3255, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3256, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3257, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3273, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3274, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3275, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3276, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3277, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3278, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3279, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3280, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3281, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3285, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3286, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3287, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3308, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3309, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3310, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3311, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3315, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3316, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3317, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3318, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3319, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3320, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3321, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3322, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3323, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3324, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3325, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3326, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3330, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3331, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3332, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3348, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3349, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3350, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3351, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3352, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3353, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3354, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3355, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3356, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3360, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3361, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3362, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3383, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3384, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3385, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3386, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3390, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3391, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3392, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3393, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3394, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3395, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3396, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3397, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3398, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3399, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3400, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3401, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3405, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3406, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3407, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3423, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3424, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3425, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3426, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3427, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3428, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3429, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3430, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3431, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3435, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3436, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3437, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3438, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3439, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3440, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3441, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3442, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3443, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3444, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3445, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3446, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3447, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3448, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3449, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3450, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ - _(3451, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3452, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3454, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3455, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(3456, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3457, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3459, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3460, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(3461, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3462, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3464, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3466, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3467, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3469, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3470, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3471, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3472, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3474, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3475, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3476, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3477, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3479, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3485, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(3486, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3487, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3489, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3492, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3494, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3497, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ - _(3499, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ - _(3500, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3501, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3502, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3503, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3503+1, ZEND_NULL) + _(2153, ZEND_SEND_USER_SPEC_CONST) \ + _(2154, ZEND_SEND_USER_SPEC_TMP) \ + _(2157, ZEND_SEND_USER_SPEC_CV) \ + _(2158, ZEND_STRLEN_SPEC_CONST) \ + _(2159, ZEND_STRLEN_SPEC_TMP) \ + _(2162, ZEND_STRLEN_SPEC_CV) \ + _(2163, ZEND_DEFINED_SPEC_CONST) \ + _(2164, ZEND_TYPE_CHECK_SPEC_CONST) \ + _(2165, ZEND_TYPE_CHECK_SPEC_TMP) \ + _(2168, ZEND_TYPE_CHECK_SPEC_CV) \ + _(2169, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \ + _(2170, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \ + _(2171, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \ + _(2172, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \ + _(2173, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \ + _(2174, ZEND_FE_RESET_RW_SPEC_CONST) \ + _(2175, ZEND_FE_RESET_RW_SPEC_TMP) \ + _(2176, ZEND_FE_RESET_RW_SPEC_VAR) \ + _(2178, ZEND_FE_RESET_RW_SPEC_CV) \ + _(2179, ZEND_FE_FETCH_RW_SPEC_VAR) \ + _(2180, ZEND_FE_FREE_SPEC_TMPVAR) \ + _(2181, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \ + _(2182, ZEND_INIT_DYNAMIC_CALL_SPEC_TMP) \ + _(2185, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \ + _(2186, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \ + _(2187, ZEND_DO_ICALL_SPEC_RETVAL_USED) \ + _(2188, ZEND_DO_ICALL_SPEC_OBSERVER) \ + _(2189, ZEND_DO_ICALL_SPEC_OBSERVER) \ + _(2190, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \ + _(2191, ZEND_DO_UCALL_SPEC_RETVAL_USED) \ + _(2192, ZEND_DO_UCALL_SPEC_OBSERVER) \ + _(2193, ZEND_DO_UCALL_SPEC_OBSERVER) \ + _(2194, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \ + _(2195, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \ + _(2196, ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER) \ + _(2197, ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER) \ + _(2208, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \ + _(2209, ZEND_PRE_INC_OBJ_SPEC_VAR_TMP) \ + _(2212, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \ + _(2213, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2214, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP) \ + _(2217, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \ + _(2218, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \ + _(2219, ZEND_PRE_INC_OBJ_SPEC_CV_TMP) \ + _(2222, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \ + _(2233, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \ + _(2234, ZEND_POST_INC_OBJ_SPEC_VAR_TMP) \ + _(2237, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \ + _(2238, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2239, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP) \ + _(2242, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \ + _(2243, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \ + _(2244, ZEND_POST_INC_OBJ_SPEC_CV_TMP) \ + _(2247, ZEND_POST_INC_OBJ_SPEC_CV_CV) \ + _(2248, ZEND_ECHO_SPEC_CONST) \ + _(2249, ZEND_ECHO_SPEC_TMP) \ + _(2252, ZEND_ECHO_SPEC_CV) \ + _(2259, ZEND_INSTANCEOF_SPEC_TMP_CONST) \ + _(2261, ZEND_INSTANCEOF_SPEC_TMP_VAR) \ + _(2262, ZEND_INSTANCEOF_SPEC_TMP_UNUSED) \ + _(2274, ZEND_INSTANCEOF_SPEC_CV_CONST) \ + _(2276, ZEND_INSTANCEOF_SPEC_CV_VAR) \ + _(2277, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \ + _(2279, ZEND_GENERATOR_CREATE_SPEC) \ + _(2282, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \ + _(2284, ZEND_MAKE_REF_SPEC_CV_UNUSED) \ + _(2285, ZEND_DECLARE_FUNCTION_SPEC) \ + _(2286, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_UNUSED) \ + _(2287, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ + _(2288, ZEND_DECLARE_CLASS_SPEC_CONST) \ + _(2289, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \ + _(2290, ZEND_DECLARE_ANON_CLASS_SPEC) \ + _(2291, ZEND_ADD_ARRAY_UNPACK_SPEC) \ + _(2292, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ + _(2293, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMP) \ + _(2296, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ + _(2297, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CONST) \ + _(2298, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_TMP) \ + _(2301, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CV) \ + _(2307, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ + _(2308, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP) \ + _(2311, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ + _(2312, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ + _(2313, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP) \ + _(2316, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ + _(2317, ZEND_HANDLE_EXCEPTION_SPEC) \ + _(2318, ZEND_USER_OPCODE_SPEC) \ + _(2319, ZEND_ASSERT_CHECK_SPEC) \ + _(2320, ZEND_JMP_SET_SPEC_CONST) \ + _(2321, ZEND_JMP_SET_SPEC_TMP) \ + _(2324, ZEND_JMP_SET_SPEC_CV) \ + _(2325, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ + _(2326, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ + _(2327, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ + _(2328, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ + _(2329, ZEND_FETCH_LIST_W_SPEC_VAR_TMP) \ + _(2332, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ + _(2333, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ + _(2335, ZEND_FETCH_CLASS_NAME_SPEC_TMP) \ + _(2337, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ + _(2338, ZEND_FETCH_CLASS_NAME_SPEC_CV) \ + _(2339, ZEND_CALL_TRAMPOLINE_SPEC) \ + _(2340, ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER) \ + _(2341, ZEND_DISCARD_EXCEPTION_SPEC) \ + _(2342, ZEND_YIELD_SPEC_CONST_CONST) \ + _(2343, ZEND_YIELD_SPEC_CONST_TMP) \ + _(2345, ZEND_YIELD_SPEC_CONST_UNUSED) \ + _(2346, ZEND_YIELD_SPEC_CONST_CV) \ + _(2347, ZEND_YIELD_SPEC_TMP_CONST) \ + _(2348, ZEND_YIELD_SPEC_TMP_TMP) \ + _(2350, ZEND_YIELD_SPEC_TMP_UNUSED) \ + _(2351, ZEND_YIELD_SPEC_TMP_CV) \ + _(2352, ZEND_YIELD_SPEC_VAR_CONST) \ + _(2353, ZEND_YIELD_SPEC_VAR_TMP) \ + _(2355, ZEND_YIELD_SPEC_VAR_UNUSED) \ + _(2356, ZEND_YIELD_SPEC_VAR_CV) \ + _(2357, ZEND_YIELD_SPEC_UNUSED_CONST) \ + _(2358, ZEND_YIELD_SPEC_UNUSED_TMP) \ + _(2360, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ + _(2361, ZEND_YIELD_SPEC_UNUSED_CV) \ + _(2362, ZEND_YIELD_SPEC_CV_CONST) \ + _(2363, ZEND_YIELD_SPEC_CV_TMP) \ + _(2365, ZEND_YIELD_SPEC_CV_UNUSED) \ + _(2366, ZEND_YIELD_SPEC_CV_CV) \ + _(2367, ZEND_GENERATOR_RETURN_SPEC_CONST) \ + _(2368, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ + _(2369, ZEND_GENERATOR_RETURN_SPEC_TMP) \ + _(2370, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ + _(2371, ZEND_GENERATOR_RETURN_SPEC_VAR) \ + _(2372, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ + _(2375, ZEND_GENERATOR_RETURN_SPEC_CV) \ + _(2376, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ + _(2377, ZEND_FAST_CALL_SPEC) \ + _(2378, ZEND_FAST_RET_SPEC) \ + _(2379, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ + _(2380, ZEND_SEND_UNPACK_SPEC) \ + _(2381, ZEND_YIELD_FROM_SPEC_CONST) \ + _(2382, ZEND_YIELD_FROM_SPEC_TMP) \ + _(2385, ZEND_YIELD_FROM_SPEC_CV) \ + _(2386, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ + _(2387, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ + _(2388, ZEND_COALESCE_SPEC_CONST) \ + _(2389, ZEND_COALESCE_SPEC_TMP) \ + _(2392, ZEND_COALESCE_SPEC_CV) \ + _(2393, ZEND_SPACESHIP_SPEC_CONST_CONST) \ + _(2394, ZEND_SPACESHIP_SPEC_CONST_TMP) \ + _(2397, ZEND_SPACESHIP_SPEC_CONST_CV) \ + _(2398, ZEND_SPACESHIP_SPEC_TMP_CONST) \ + _(2399, ZEND_SPACESHIP_SPEC_TMP_TMP) \ + _(2402, ZEND_SPACESHIP_SPEC_TMP_CV) \ + _(2413, ZEND_SPACESHIP_SPEC_CV_CONST) \ + _(2414, ZEND_SPACESHIP_SPEC_CV_TMP) \ + _(2417, ZEND_SPACESHIP_SPEC_CV_CV) \ + _(2418, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ + _(2419, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ + _(2422, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ + _(2424, ZEND_FETCH_STATIC_PROP_R_SPEC) \ + _(2425, ZEND_FETCH_STATIC_PROP_W_SPEC) \ + _(2426, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ + _(2427, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ + _(2428, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ + _(2429, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ + _(2430, ZEND_UNSET_STATIC_PROP_SPEC) \ + _(2431, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ + _(2432, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ + _(2433, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ + _(2434, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ + _(2436, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ + _(2442, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ + _(2443, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ + _(2444, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ + _(2446, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ + _(2447, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ + _(2448, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ + _(2449, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ + _(2451, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ + _(2457, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ + _(2458, ZEND_BIND_STATIC_SPEC_CV) \ + _(2459, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ + _(2460, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \ + _(2463, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \ + _(2465, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ + _(2466, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ + _(2467, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2468, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2470, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2471, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ + _(2472, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2473, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2475, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2476, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ + _(2477, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ + _(2480, ZEND_IN_ARRAY_SPEC_CV_CONST) \ + _(2481, ZEND_COUNT_SPEC_CONST_UNUSED) \ + _(2482, ZEND_COUNT_SPEC_TMP_UNUSED) \ + _(2485, ZEND_COUNT_SPEC_CV_UNUSED) \ + _(2486, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ + _(2487, ZEND_GET_CLASS_SPEC_TMP_UNUSED) \ + _(2489, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ + _(2490, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ + _(2491, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ + _(2492, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ + _(2493, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ + _(2496, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ + _(2497, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ + _(2498, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMP) \ + _(2501, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ + _(2502, ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CONST) \ + _(2503, ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_TMP) \ + _(2506, ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CV) \ + _(2517, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ + _(2518, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMP) \ + _(2521, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ + _(2522, ZEND_MATCH_SPEC_CONST_CONST) \ + _(2523, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2524, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2526, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2527, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ + _(2528, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ + _(2531, ZEND_CASE_STRICT_SPEC_TMP_CV) \ + _(2532, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ + _(2533, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2534, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2536, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2537, ZEND_JMP_NULL_SPEC_CONST) \ + _(2538, ZEND_JMP_NULL_SPEC_TMP) \ + _(2541, ZEND_JMP_NULL_SPEC_CV) \ + _(2542, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ + _(2543, ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED) \ + _(2544, ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED) \ + _(2545, ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED) \ + _(2546, ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV) \ + _(2547, ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED) \ + _(2548, ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER) \ + _(2549, ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED) \ + _(2550, ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER) \ + _(2551, ZEND_FRAMELESS_ICALL_2_SPEC) \ + _(2552, ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER) \ + _(2553, ZEND_FRAMELESS_ICALL_3_SPEC) \ + _(2554, ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER) \ + _(2555, ZEND_JMP_FRAMELESS_SPEC_CONST) \ + _(2556, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED) \ + _(2557, ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST) \ + _(2558, ZEND_TYPE_ASSERT_SPEC_CONST) \ + _(2559, ZEND_CALLABLE_CONVERT_PARTIAL_SPEC_CONST_CONST) \ + _(2562, ZEND_CALLABLE_CONVERT_PARTIAL_SPEC_CONST_UNUSED) \ + _(2564, ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_CONST) \ + _(2567, ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_UNUSED) \ + _(2569, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \ + _(2570, ZEND_RECV_NOTYPE_SPEC) \ + _(2572, ZEND_COUNT_ARRAY_SPEC_TMP_UNUSED) \ + _(2575, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \ + _(2576, ZEND_JMP_FORWARD_SPEC) \ + _(2582, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2583, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2584, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2586, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2587, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2588, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2589, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2591, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2597, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2598, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2599, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2601, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2607, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2608, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2609, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2611, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2612, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2613, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2614, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2616, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2622, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2623, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2624, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2626, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2632, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2633, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2634, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2636, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2637, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2638, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2639, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2641, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2647, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2648, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2649, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2651, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2653, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2654, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2656, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2657, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2658, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2659, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2661, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2662, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2663, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2664, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2666, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2672, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2673, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2674, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2676, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2678, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2679, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2681, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2682, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2683, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2684, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2686, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2687, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2688, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2689, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2691, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2697, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2698, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2699, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2701, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2703, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2704, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2706, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2707, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2708, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2709, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2711, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2712, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2713, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2714, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2716, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2722, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2723, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2724, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2726, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2732, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2733, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2734, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2736, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2737, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2738, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2739, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2741, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2747, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2748, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2749, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2751, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2757, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2758, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2759, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2761, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2762, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2763, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2764, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2766, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2772, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2773, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2774, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2776, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2782, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2783, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2784, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2786, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2787, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2788, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2789, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2791, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2797, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2798, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2799, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2801, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2817, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2818, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2819, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2820, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2821, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2822, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2823, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2824, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2825, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2829, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2830, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2831, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2832, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2845, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2862, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2863, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2864, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2865, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2866, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2867, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2868, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2869, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2870, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2874, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2875, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2876, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2892, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2893, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2894, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2895, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2896, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2897, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2898, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2899, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2900, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2904, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2905, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2906, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2907, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2920, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2937, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2938, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2939, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2940, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2941, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2942, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2943, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2944, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2945, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2949, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2950, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2951, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2967, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2968, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2969, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2970, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2971, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2972, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2973, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2974, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2975, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2979, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2980, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2981, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2982, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3012, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3013, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3014, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3015, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3016, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3017, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3018, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3019, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3020, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3024, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3025, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3026, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3042, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3043, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3044, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3045, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3046, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3047, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3048, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3049, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3050, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3054, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3055, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3056, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3057, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3087, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3088, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3089, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3090, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3091, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3092, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3093, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3094, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3095, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3099, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3100, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3101, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3102, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ + _(3103, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3104, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3105, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \ + _(3106, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3107, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3108, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3112, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3113, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3117, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3121, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3122, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3123, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3124, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3125, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3126, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3130, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3131, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3132, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3133, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3134, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3135, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3136, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3137, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3138, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3139, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3140, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3141, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3152, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3153, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3154, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3160, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3161, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3162, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3178, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3179, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3180, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3181, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3182, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3183, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3184, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3185, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3186, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3190, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3191, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3192, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3196, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3197, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3198, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3199, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3200, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3201, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3205, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3206, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3207, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3208, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3209, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3210, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3211, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3212, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3213, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3214, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3235, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3236, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3237, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3253, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3254, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3255, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3256, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3257, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3258, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3259, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3260, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3261, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3265, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3266, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3267, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3271, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3272, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3273, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3280, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3281, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3282, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3283, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3284, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3285, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3286, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3287, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3288, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3289, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3310, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3311, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3312, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3328, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3329, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3330, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3331, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3332, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3333, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3334, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3335, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3336, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3340, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3341, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3342, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3346, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3347, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3348, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3355, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3356, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3357, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3358, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3359, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3360, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3361, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3362, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3363, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3364, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3385, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3386, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3387, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3403, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3404, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3405, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3406, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3407, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3408, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3409, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3410, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3411, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3415, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3416, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3417, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3418, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3419, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3420, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3421, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3422, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3423, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3424, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3425, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3426, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3427, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3428, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3429, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3430, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3431, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3432, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3434, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3435, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3436, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3437, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3439, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3440, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3441, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3442, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3444, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3446, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3447, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3449, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3450, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3451, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3452, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3454, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3455, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3456, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3457, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3459, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3465, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3466, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3467, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3469, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3472, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3474, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3477, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ + _(3479, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ + _(3480, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3481, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3482, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3483, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3483+1, ZEND_NULL) diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index d693242397dd..cc14862ebedd 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -359,7 +359,7 @@ static uint32_t zend_vm_opcodes_flags[214] = { 0x00001301, 0x01000303, 0x01000000, - 0x00001303, + 0x00001003, 0x00000003, 0x00040003, 0x09000003, diff --git a/ext/opcache/tests/array_map_foreach_optimization_006.phpt b/ext/opcache/tests/array_map_foreach_optimization_006.phpt index 269c49e54964..bb99b875e8f0 100644 --- a/ext/opcache/tests/array_map_foreach_optimization_006.phpt +++ b/ext/opcache/tests/array_map_foreach_optimization_006.phpt @@ -1,11 +1,10 @@ --TEST-- -array_map(): foreach optimization - dynamic name +array_map(): dynamic callable falls back to native semantics --EXTENSIONS-- opcache --INI-- opcache.enable=1 opcache.enable_cli=1 -opcache.opt_debug_level=0x20000 --FILE-- ---EXPECTF-- -$_main: - ; (lines=%d, args=0, vars=%d, tmps=%d) - ; (after optimizer) - ; %s -0000 INIT_FCALL 2 %d string("range") -0001 SEND_VAL int(1) 1 -0002 SEND_VAL int(10) 2 -0003 T3 = DO_ICALL -0004 ASSIGN CV0($array) T3 -0005 ASSIGN CV1($plus1) string("plus1") -0006 T4 = QM_ASSIGN CV1($plus1) -0007 TYPE_ASSERT 131079 string("array_map") CV0($array) -0008 T3 = INIT_ARRAY 0 (packed) NEXT -0009 V5 = FE_RESET_R CV0($array) 0017 -0010 T7 = FE_FETCH_R V5 T6 0017 -0011 T8 = COPY_TMP T4 -0012 INIT_DYNAMIC_CALL 1 T8 -0013 SEND_USER T6 1 -0014 T6 = DO_FCALL -0015 T3 = ADD_ARRAY_ELEMENT T6 T7 -0016 JMP 0010 -0017 FE_FREE V5 -0018 FREE T4 -0019 ASSIGN CV2($foo) T3 -0020 INIT_FCALL 1 %d string("var_dump") -0021 SEND_VAR CV2($foo) 1 -0022 DO_ICALL -0023 RETURN int(1) -LIVE RANGES: - 4: 0007 - 0018 (tmp/var) - 3: 0009 - 0019 (tmp/var) - 5: 0010 - 0017 (loop) - 6: 0011 - 0013 (tmp/var) - 7: 0011 - 0015 (tmp/var) - -plus1: - ; (lines=3, args=1, vars=1, tmps=%d) - ; (after optimizer) - ; %s -0000 CV0($x) = RECV 1 -0001 T1 = ADD CV0($x) int(1) -0002 RETURN T1 +--EXPECT-- array(10) { [0]=> int(2) diff --git a/ext/opcache/tests/array_map_foreach_optimization_012.phpt b/ext/opcache/tests/array_map_foreach_optimization_012.phpt index 195c896baf73..51a5c213dcf5 100644 --- a/ext/opcache/tests/array_map_foreach_optimization_012.phpt +++ b/ext/opcache/tests/array_map_foreach_optimization_012.phpt @@ -1,11 +1,10 @@ --TEST-- -array_map(): foreach optimization - function argument is evaluated once +array_map(): dynamic callee evaluated once on native fallback --EXTENSIONS-- opcache --INI-- opcache.enable=1 opcache.enable_cli=1 -opcache.opt_debug_level=0x20000 --FILE-- ---EXPECTF-- -$_main: - ; (lines=%d, args=0, vars=%d, tmps=%d) - ; (after optimizer) - ; %s -0000 INIT_FCALL 2 %d string("range") -0001 SEND_VAL int(1) 1 -0002 SEND_VAL int(2) 2 -0003 T2 = DO_ICALL -0004 ASSIGN CV0($array) T2 -0005 INIT_FCALL 1 %d string("var_dump") -0006 INIT_FCALL 0 %d string("get_function") -0007 T3 = DO_UCALL -0008 TYPE_ASSERT 131079 string("array_map") CV0($array) -0009 T2 = INIT_ARRAY 0 (packed) NEXT -0010 V4 = FE_RESET_R CV0($array) 0018 -0011 T8 = FE_FETCH_R V4 T7 0018 -0012 T9 = COPY_TMP T3 -0013 INIT_DYNAMIC_CALL 1 T9 -0014 SEND_USER T7 1 -0015 T7 = DO_FCALL -0016 T2 = ADD_ARRAY_ELEMENT T7 T8 -0017 JMP 0011 -0018 FE_FREE V4 -0019 FREE T3 -0020 SEND_VAL T2 1 -0021 DO_ICALL -0022 INIT_FCALL 1 %d string("var_dump") -0023 T3 = NEW 0 string("C") -0024 DO_FCALL -0025 TYPE_ASSERT 131079 string("array_map") CV0($array) -0026 T2 = INIT_ARRAY 0 (packed) NEXT -0027 V4 = FE_RESET_R CV0($array) 0036 -0028 T7 = FE_FETCH_R V4 T6 0036 -0029 T9 = COPY_TMP T3 -0030 V8 = FETCH_CLASS (exception) T9 -0031 INIT_STATIC_METHOD_CALL 1 V8 string("f") -0032 SEND_USER T6 1 -0033 T6 = DO_FCALL -0034 T2 = ADD_ARRAY_ELEMENT T6 T7 -0035 JMP 0028 -0036 FE_FREE V4 -0037 FREE T3 -0038 SEND_VAL T2 1 -0039 DO_ICALL -0040 T2 = DECLARE_LAMBDA_FUNCTION 4294967295 0 -0041 BIND_LEXICAL (ref) T2 CV1($f) -0042 ASSIGN CV1($f) T2 -0043 INIT_FCALL 1 %d string("var_dump") -0044 T3 = QM_ASSIGN CV1($f) -0045 TYPE_ASSERT 131079 string("array_map") CV0($array) -0046 T2 = INIT_ARRAY 0 (packed) NEXT -0047 V4 = FE_RESET_R CV0($array) 0055 -0048 T6 = FE_FETCH_R V4 T5 0055 -0049 T7 = COPY_TMP T3 -0050 INIT_DYNAMIC_CALL 1 T7 -0051 SEND_USER T5 1 -0052 T5 = DO_FCALL -0053 T2 = ADD_ARRAY_ELEMENT T5 T6 -0054 JMP 0048 -0055 FE_FREE V4 -0056 FREE T3 -0057 SEND_VAL T2 1 -0058 DO_ICALL -0059 RETURN int(1) -LIVE RANGES: - 3: 0008 - 0019 (tmp/var) - 2: 0010 - 0020 (tmp/var) - 4: 0011 - 0018 (loop) - 7: 0012 - 0014 (tmp/var) - 8: 0012 - 0016 (tmp/var) - 3: 0024 - 0025 (new) - 3: 0025 - 0037 (tmp/var) - 2: 0027 - 0038 (tmp/var) - 4: 0028 - 0036 (loop) - 6: 0029 - 0032 (tmp/var) - 7: 0029 - 0034 (tmp/var) - 2: 0041 - 0042 (tmp/var) - 3: 0045 - 0056 (tmp/var) - 2: 0047 - 0057 (tmp/var) - 4: 0048 - 0055 (loop) - 5: 0049 - 0051 (tmp/var) - 6: 0049 - 0053 (tmp/var) - -{closure:%s:%d}: - ; (lines=5, args=1, vars=2, tmps=%d) - ; (after optimizer) - ; %s.php:%s -0000 CV0($value) = RECV 1 -0001 BIND_STATIC (ref) CV1($f) -0002 ASSIGN CV1($f) string("dechex") -0003 T2 = ADD CV0($value) int(1) -0004 RETURN T2 - -plusn: - ; (lines=4, args=2, vars=2, tmps=%d) - ; (after optimizer) - ; %s -0000 CV0($x) = RECV 1 -0001 CV1($n) = RECV 2 -0002 T2 = ADD CV0($x) CV1($n) -0003 RETURN T2 - -get_function: - ; (lines=7, args=0, vars=0, tmps=%d) - ; (after optimizer) - ; %s.php:%s -0000 INIT_FCALL 1 %d string("var_dump") -0001 SEND_VAL string("get_function") 1 -0002 DO_ICALL -0003 V1 = DECLARE_ANON_CLASS string("class@anonymous%s") -0004 T0 = NEW 0 V1 -0005 DO_FCALL -0006 RETURN T0 -LIVE RANGES: - 0: 0005 - 0006 (new) - -class@anonymous::__invoke: - ; (lines=3, args=1, vars=1, tmps=%d) - ; (after optimizer) - ; %s.php:%s -0000 CV0($value) = RECV 1 -0001 T1 = ADD CV0($value) int(1) -0002 RETURN T1 - -C::__construct: - ; (lines=4, args=0, vars=0, tmps=%d) - ; (after optimizer) - ; %s.php:%s -0000 INIT_FCALL 1 %d string("var_dump") -0001 SEND_VAL string("C::__construct") 1 -0002 DO_ICALL -0003 RETURN null - -C::f: - ; (lines=3, args=1, vars=1, tmps=%d) - ; (after optimizer) - ; %s.php:%s -0000 CV0($value) = RECV 1 -0001 T1 = ADD CV0($value) int(1) -0002 RETURN T1 +--EXPECT-- string(12) "get_function" array(2) { [0]=> diff --git a/ext/opcache/tests/array_map_foreach_optimization_014.phpt b/ext/opcache/tests/array_map_foreach_optimization_014.phpt index 2320b0fa9d3e..f1c9a0569526 100644 --- a/ext/opcache/tests/array_map_foreach_optimization_014.phpt +++ b/ext/opcache/tests/array_map_foreach_optimization_014.phpt @@ -1,11 +1,10 @@ --TEST-- -array_map(): foreach optimization - PFAs with literal args are optimizable +array_map(): unresolved PFA callback uses native fallback --EXTENSIONS-- opcache --INI-- opcache.enable=1 opcache.enable_cli=1 -opcache.opt_debug_level=0x20000 --ENV-- A=1 --FILE-- @@ -20,48 +19,7 @@ if (getenv('A')) { var_dump(array_map(plusn(?, 2), range(1, 2))); ?> ---EXPECTF-- -$_main: - ; (lines=%d, args=0, vars=%d, tmps=%d) - ; (after optimizer) - ; %s -0000 INIT_FCALL 1 %d string("getenv") -0001 SEND_VAL string("A") 1 -0002 T0 = DO_ICALL -0003 JMPZ T0 0005 -0004 DECLARE_FUNCTION string("plusn") 0 -0005 INIT_FCALL 1 %d string("var_dump") -0006 INIT_FCALL 2 %d string("range") -0007 SEND_VAL int(1) 1 -0008 SEND_VAL int(2) 2 -0009 T3 = DO_ICALL -0010 TYPE_ASSERT 131079 string("array_map") T3 -0011 T0 = INIT_ARRAY 0 (packed) NEXT -0012 V1 = FE_RESET_R T3 0020 -0013 T3 = FE_FETCH_R V1 T2 0020 -0014 INIT_FCALL_BY_NAME 2 string("plusn") -0015 SEND_USER T2 1 -0016 SEND_VAL_EX int(2) 2 -0017 T2 = DO_FCALL_BY_NAME -0018 T0 = ADD_ARRAY_ELEMENT T2 T3 -0019 JMP 0013 -0020 FE_FREE V1 -0021 SEND_VAL T0 1 -0022 DO_ICALL -0023 RETURN int(1) -LIVE RANGES: - 3: 0010 - 0012 (tmp/var) - 0: 0012 - 0021 (tmp/var) - 1: 0013 - 0020 (loop) - -plusn: - ; (lines=4, args=2, vars=2, tmps=%d) - ; (after optimizer) - ; %s -0000 CV0($x) = RECV 1 -0001 CV1($n) = RECV 2 -0002 T2 = ADD CV0($x) CV1($n) -0003 RETURN T2 +--EXPECT-- array(2) { [0]=> int(3) From de35c9d912ff038092d40cf31af5317451d9f7b5 Mon Sep 17 00:00:00 2001 From: Pratik Bhujel Date: Thu, 19 Nov 2026 22:34:57 +0545 Subject: [PATCH 4/6] Update empty array_map callback test for native fallback --- ext/opcache/tests/array_map_foreach_optimization_010.phpt | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/ext/opcache/tests/array_map_foreach_optimization_010.phpt b/ext/opcache/tests/array_map_foreach_optimization_010.phpt index 758c3504a88f..4490b29beead 100644 --- a/ext/opcache/tests/array_map_foreach_optimization_010.phpt +++ b/ext/opcache/tests/array_map_foreach_optimization_010.phpt @@ -82,8 +82,7 @@ array(1) { string(15) "trusted:payload" } empty direct -array(0) { -} +Error: Call to undefined function cand_86013_missing() empty dynamic-call control Error: Call to undefined function cand_86013_missing() direct array_map static call From 54d2d438dece462d96a447744ca0a6477677737e Mon Sep 17 00:00:00 2001 From: Pratik Bhujel Date: Thu, 19 Nov 2026 23:22:29 +0545 Subject: [PATCH 5/6] test: expect PFA closure warnings for array_map by-ref fallback --- Zend/tests/array_map_foreach_optimization_gh25379.phpt | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Zend/tests/array_map_foreach_optimization_gh25379.phpt b/Zend/tests/array_map_foreach_optimization_gh25379.phpt index 41a75b0233dc..9469a44d10ab 100644 --- a/Zend/tests/array_map_foreach_optimization_gh25379.phpt +++ b/Zend/tests/array_map_foreach_optimization_gh25379.phpt @@ -250,7 +250,7 @@ array(1) { bool(true) } -Warning: inc2(): Argument #1 ($x) must be passed by reference, value given in %s on line %d +Warning: {closure:pfa:%s}(): Argument #1 ($x) must be passed by reference, value given in %s on line %d array(1) { [0]=> int(3) @@ -271,7 +271,7 @@ array(1) { int(2) } -Warning: inc2(): Argument #1 ($x) must be passed by reference, value given in %s on line %d +Warning: {closure:pfa:%s}(): Argument #1 ($x) must be passed by reference, value given in %s on line %d array(1) { [0]=> int(4) @@ -313,7 +313,7 @@ array(1) { int(2) } -Warning: later2(): Argument #1 ($x) must be passed by reference, value given in %s on line %d +Warning: {closure:pfa:%s}(): Argument #1 ($x) must be passed by reference, value given in %s on line %d array(1) { [0]=> int(4) From 1bf9f93ab9fc3a9304a09523b1fbf399b4965c7a Mon Sep 17 00:00:00 2001 From: Pratik Bhujel Date: Sat, 21 Nov 2026 10:20:14 +0545 Subject: [PATCH 6/6] Fix GH-25379: do not walk unlinked parents in array_map method lookup --- ...timization_gh25379_reference_elements.phpt | 94 +++++ Zend/zend_compile.c | 348 +++++------------- 2 files changed, 182 insertions(+), 260 deletions(-) diff --git a/Zend/tests/array_map_foreach_optimization_gh25379_reference_elements.phpt b/Zend/tests/array_map_foreach_optimization_gh25379_reference_elements.phpt index 984996fa8579..60542c0d9553 100644 --- a/Zend/tests/array_map_foreach_optimization_gh25379_reference_elements.phpt +++ b/Zend/tests/array_map_foreach_optimization_gh25379_reference_elements.phpt @@ -13,6 +13,65 @@ class ByRefMethod { return ++$x; } } +class ParentByValue { + public static function m($x) { + return $x + 1; + } +} +trait ByRefTrait { + public static function m($y, &...$x) { + return ++$x[0]; + } +} +class DeclaredLater extends ParentByValue { + public static function positional() { + $a = [1, 2]; + $r = &$a[0]; + $res = array_map(self::m(0, ?), $a); + return [$res, $a]; + } + public static function named() { + $a = [1, 2]; + $r = &$a[0]; + $res = array_map(self::m(0, x: ?), $a); + return [$res, $a]; + } + public static function byClassName() { + $a = [1, 2]; + $r = &$a[0]; + $res = array_map(DeclaredLater::m(0, ?), $a); + return [$res, $a]; + } + public static function m($y, &$x = null) { + return ++$x; + } +} +class FromTrait extends ParentByValue { + use ByRefTrait; + + public static function variadic() { + $a = [1, 2]; + $r = &$a[0]; + $res = array_map(self::m(0, ?), $a); + return [$res, $a]; + } +} +class ChildOfFromTrait extends FromTrait { + public static function viaParent() { + $a = [1, 2]; + $r = &$a[0]; + $res = array_map(parent::m(0, ?), $a); + return [$res, $a]; + } +} +function preboundRef(&$a, $b) { + return $b + 1; +} +class NonStaticMethod { + public function inst($x) { + return $x + 1; + } +} function test(string $name, Closure $c) { echo $name, ':', PHP_EOL; try { @@ -45,6 +104,14 @@ test('by-value callee', function () { $res = array_map(byValue(...), $a); return [$res, $a]; }); +test('declared later, positional', DeclaredLater::positional(...)); +test('declared later, named', DeclaredLater::named(...)); +test('declared later, class name', DeclaredLater::byClassName(...)); +test('from trait, variadic', FromTrait::variadic(...)); +test('parent from trait', ChildOfFromTrait::viaParent(...)); +test('prebound by-ref literal on empty array', fn () => array_map(preboundRef(0, ?), [])); +test('non-static method on empty array', fn () => array_map(NonStaticMethod::inst(...), [])); +test('parent in free function', fn () => eval('function _gh25379_free() { return array_map(parent::m(...), [1]); }')); function later(&$x) { return ++$x; } @@ -64,3 +131,30 @@ Warning: ByRefMethod::change(): Argument #1 ($x) must be passed by reference, va [[2,3],[2,2]] by-value callee: [[2,3],[1,2]] +declared later, positional: + +Warning: DeclaredLater::{closure:pfa:DeclaredLater::positional():%d}(): Argument #1 ($x) must be passed by reference, value given in %s on line %d +[[2,3],[2,2]] +declared later, named: + +Warning: DeclaredLater::{closure:pfa:DeclaredLater::named():%d}(): Argument #1 ($x) must be passed by reference, value given in %s on line %d +[[2,3],[2,2]] +declared later, class name: + +Warning: DeclaredLater::{closure:pfa:DeclaredLater::byClassName():%d}(): Argument #1 ($x) must be passed by reference, value given in %s on line %d +[[2,3],[2,2]] +from trait, variadic: + +Warning: FromTrait::{closure:pfa:FromTrait::variadic():%d}(): Argument #1 ($x0) must be passed by reference, value given in %s on line %d +[[2,3],[2,2]] +parent from trait: + +Warning: FromTrait::{closure:pfa:ChildOfFromTrait::viaParent():%d}(): Argument #1 ($x0) must be passed by reference, value given in %s on line %d +[[2,3],[2,2]] +prebound by-ref literal on empty array: +Error: preboundRef(): Argument #1 ($a) could not be passed by reference +non-static method on empty array: +Error: Non-static method NonStaticMethod::inst() cannot be called statically +parent in free function: + +Fatal error: Cannot use "parent" when no class scope is active in %s(%d) : eval()'d code on line 1 diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 2b446acda295..5aedda83edb2 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -5355,9 +5355,9 @@ static const zend_class_entry *zend_resolve_compile_time_parent(const zend_class /* }}} */ /* FE_FETCH_R dereferences array elements, while array_map() preserves references - * when passing them to callbacks. Only inline a callback whose mapped argument - * is known at compile time to be passed by value. */ -static bool zend_array_map_callback_takes_value(zend_ast *callback, uint32_t arg_num, zend_string *arg_name) + * when passing them to callbacks. Only inline a callback whose target function + * or method is statically known and takes the mapped argument by value. */ +static bool zend_array_map_callback_is_optimizable(zend_ast *callback, const zend_ast_list *fcc_args) /* {{{ */ { zend_ast *name_ast = callback->child[callback->kind == ZEND_AST_CALL ? 0 : 1]; if (name_ast->kind != ZEND_AST_ZVAL || Z_TYPE_P(zend_ast_get_zval(name_ast)) != IS_STRING) { @@ -5365,6 +5365,7 @@ static bool zend_array_map_callback_takes_value(zend_ast *callback, uint32_t arg } const zend_function *fbc = NULL; + uint32_t fetch_type = ZEND_FETCH_CLASS_DEFAULT; if (callback->kind == ZEND_AST_CALL) { bool is_fully_qualified; zend_string *resolved = zend_resolve_function_name( @@ -5384,229 +5385,138 @@ static bool zend_array_map_callback_takes_value(zend_ast *callback, uint32_t arg } const zend_class_entry *ce = NULL; - uint32_t fetch_type = zend_get_class_fetch_type(zend_ast_get_str(class_ast)); + fetch_type = zend_get_class_fetch_type_ast(class_ast); if (fetch_type == ZEND_FETCH_CLASS_DEFAULT) { zend_string *class_name = zend_resolve_class_name_ast(class_ast); zend_string *lcname = zend_string_tolower(class_name); ce = zend_hash_find_ptr(CG(class_table), lcname); zend_string_release_ex(lcname, 0); - if (!ce && CG(active_class_entry) + if (ce) { + if (zend_compile_ignore_class(ce, CG(active_op_array)->filename)) { + ce = NULL; + } + } else if (CG(active_class_entry) && zend_string_equals_ci(CG(active_class_entry)->name, class_name)) { ce = CG(active_class_entry); } zend_string_release_ex(class_name, 0); - } else if (fetch_type == ZEND_FETCH_CLASS_SELF && zend_is_scope_known()) { + } else if (fetch_type == ZEND_FETCH_CLASS_SELF && CG(active_class_entry) && zend_is_scope_known()) { ce = CG(active_class_entry); - } else if (fetch_type == ZEND_FETCH_CLASS_PARENT && zend_is_scope_known()) { + } else if (fetch_type == ZEND_FETCH_CLASS_PARENT && CG(active_class_entry) && zend_is_scope_known()) { ce = zend_resolve_compile_time_parent(CG(active_class_entry)); } - if (!ce) { + if (!ce || (ce->ce_flags & ZEND_ACC_TRAIT)) { return false; } + /* Only look up on ce itself: linked classes already include inherited + * and trait methods in function_table, while an unlinked class (such as + * CG(active_class_entry) or one using traits) may override a parent + * method via a trait or a declaration later in the class body. */ zend_string *lcname = zend_string_tolower(zend_ast_get_str(name_ast)); - for (const zend_class_entry *cur_ce = ce; cur_ce && !fbc; cur_ce = zend_resolve_compile_time_parent(cur_ce)) { - if (!zend_compile_ignore_class(cur_ce, CG(active_op_array)->filename)) { - fbc = zend_get_compatible_func_or_null(cur_ce, lcname); - } - } + fbc = zend_get_compatible_func_or_null(ce, lcname); zend_string_release_ex(lcname, 0); } - if (!fbc || !fbc_is_finalized(fbc) || (fbc->common.fn_flags2 & ZEND_ACC2_FORBID_DYN_CALLS)) { + if (!fbc + || !fbc_is_finalized(fbc) + || (fbc->common.fn_flags & ZEND_ACC_ABSTRACT) + || (fbc->common.fn_flags2 & ZEND_ACC2_FORBID_DYN_CALLS)) { return false; } - if (arg_name) { - arg_num = zend_get_arg_num(fbc, arg_name); - } - return arg_num != (uint32_t) -1 && !ARG_SHOULD_BE_SENT_BY_REF(fbc, arg_num); -} - -static zend_result zend_compile_func_array_map(znode *result, zend_ast_list *args, zend_string *lcname, uint32_t lineno, uint32_t type) /* {{{ */ -{ - /* array_map() as an internal function calls the callback as if strict_types=0, - * this optimization is therefore not legal if strict_types=1. */ - if (CG(active_op_array)->fn_flags & ZEND_ACC_STRICT_TYPES) { - return FAILURE; - } - /* Bail out if we do not have exactly two parameters. */ - if (args->children != 2) { - return FAILURE; - } - - /* Bail out if callback is not a first class callable */ - zend_ast *callback = args->child[0]; - if (callback->kind != ZEND_AST_CALL && callback->kind != ZEND_AST_STATIC_CALL) { - return FAILURE; - } - - zend_ast *args_ast = zend_ast_call_get_args(callback); - if (args_ast->kind != ZEND_AST_CALLABLE_CONVERT) { - return FAILURE; - } - - if (callback->kind == ZEND_AST_CALL - && !zend_is_pipe_optimizable_callable_name(callback->child[0])) { - return FAILURE; + if (callback->kind == ZEND_AST_STATIC_CALL + && !(fbc->common.fn_flags & ZEND_ACC_STATIC) + && (!zend_is_scope_known() || !CG(active_class_entry) + || (CG(active_op_array)->fn_flags & ZEND_ACC_STATIC) + || (fetch_type != ZEND_FETCH_CLASS_SELF && fetch_type != ZEND_FETCH_CLASS_PARENT))) { + return false; } - /* PFAs with non-literal pre-bound arguments are not optimizable because we - * can't memoize arguments without breaking pass-by-reference. - * Also reject cases that zend_partial_apply() will refuse before emitting - * any bytecode for the callee expression. */ - zend_ast_fcc *fcc = (zend_ast_fcc*)args_ast; - zend_ast_list *fcc_args = zend_ast_get_list(fcc->args); bool uses_named_args = false; bool has_placeholder = false; - uint32_t mapped_arg_num = 0; - zend_string *mapped_arg_name = NULL; + uint32_t positional_count = 0; for (uint32_t i = 0; i < fcc_args->children; i++) { zend_ast *arg = fcc_args->child[i]; + uint32_t arg_num; if (arg->kind == ZEND_AST_NAMED_ARG) { - if (arg->child[1]->kind == ZEND_AST_PLACEHOLDER_ARG) { - mapped_arg_name = zend_ast_get_str(arg->child[0]); - } uses_named_args = true; + arg_num = zend_get_arg_num(fbc, zend_ast_get_str(arg->child[0])); + if (arg_num == (uint32_t) -1 || arg_num <= positional_count) { + return false; + } + for (uint32_t j = positional_count; j < i; j++) { + if (zend_string_equals(zend_ast_get_str(fcc_args->child[j]->child[0]), + zend_ast_get_str(arg->child[0]))) { + return false; + } + } arg = arg->child[1]; + } else { + if (uses_named_args) { + return false; + } + arg_num = ++positional_count; } if (arg->kind == ZEND_AST_PLACEHOLDER_ARG) { if (has_placeholder) { - return FAILURE; + return false; } if (arg->attr == ZEND_PLACEHOLDER_VARIADIC && uses_named_args) { - return FAILURE; + return false; + } + if (ARG_SHOULD_BE_SENT_BY_REF(fbc, arg_num)) { + return false; } has_placeholder = true; - mapped_arg_num = i + 1; continue; } - if (arg->kind != ZEND_AST_ZVAL) { - return FAILURE; + if (arg->kind != ZEND_AST_ZVAL || ARG_MUST_BE_SENT_BY_REF(fbc, arg_num)) { + return false; } } - if (!has_placeholder || !zend_array_map_callback_takes_value(callback, mapped_arg_num, mapped_arg_name)) { + return has_placeholder; +} +/* }}} */ + +static zend_result zend_compile_func_array_map(znode *result, zend_ast_list *args, zend_string *lcname, uint32_t lineno) /* {{{ */ +{ + /* array_map() as an internal function calls the callback as if strict_types=0, + * this optimization is therefore not legal if strict_types=1. */ + if (CG(active_op_array)->fn_flags & ZEND_ACC_STRICT_TYPES) { return FAILURE; } - zend_ast *func_name_ast = callback->child[callback->kind == ZEND_AST_CALL ? 0 : 1]; - if (callback->kind == ZEND_AST_CALL - && func_name_ast->kind == ZEND_AST_ZVAL - && Z_TYPE_P(zend_ast_get_zval(func_name_ast)) == IS_STRING) { - bool is_fully_qualified; - zend_string *resolved_name = zend_resolve_function_name( - zend_ast_get_str(func_name_ast), func_name_ast->attr, &is_fully_qualified); - zend_string *callee_lcname = zend_string_tolower(resolved_name); - const zend_function *callee_fbc = zend_hash_find_ptr(CG(function_table), callee_lcname); - zend_string_release_ex(resolved_name, 0); - zend_string_release_ex(callee_lcname, 0); + /* Bail out if we do not have exactly two parameters. */ + if (args->children != 2) { + return FAILURE; + } - if (callee_fbc - && (!fbc_is_finalized(callee_fbc) - || zend_compile_ignore_function(callee_fbc, CG(active_op_array)->filename))) { - callee_fbc = NULL; - } - if (callee_fbc && (callee_fbc->common.fn_flags2 & ZEND_ACC2_FORBID_DYN_CALLS)) { - return FAILURE; - } - if (!callee_fbc && !is_fully_qualified && FC(current_namespace)) { - /* Unqualified calls in a namespace fall back to the global function at runtime. */ - zend_string *global_lcname = zend_string_tolower(zend_ast_get_str(func_name_ast)); - callee_fbc = zend_hash_find_ptr(CG(function_table), global_lcname); - zend_string_release_ex(global_lcname, 0); - if (callee_fbc - && fbc_is_finalized(callee_fbc) - && !zend_compile_ignore_function(callee_fbc, CG(active_op_array)->filename) - && (callee_fbc->common.fn_flags2 & ZEND_ACC2_FORBID_DYN_CALLS)) { - return FAILURE; - } - } + /* Bail out if callback is not a first class callable */ + zend_ast *callback = args->child[0]; + if (callback->kind != ZEND_AST_CALL && callback->kind != ZEND_AST_STATIC_CALL) { + return FAILURE; } - /* Evaluate class name */ - znode class_node; - if (callback->kind == ZEND_AST_STATIC_CALL - && callback->child[0]->kind == ZEND_AST_ZVAL - && Z_TYPE_P(zend_ast_get_zval(callback->child[0])) == IS_STRING - && zend_get_class_fetch_type(zend_ast_get_str(callback->child[0])) == ZEND_FETCH_CLASS_DEFAULT) { - /* Resolve the name against the namespace and imports, as compiling it - * as an expression would yield the unresolved string. */ - class_node.op_type = IS_CONST; - ZVAL_STR(&class_node.u.constant, zend_resolve_class_name_ast(callback->child[0])); - } else if (callback->kind == ZEND_AST_STATIC_CALL) { - znode result; - zend_compile_expr(&result, callback->child[0]); - if (result.op_type == IS_CONST || result.op_type == IS_TMP_VAR) { - class_node = result; - } else { - class_node = result; - zend_emit_op_tmp(&class_node, ZEND_QM_ASSIGN, &result, NULL); - } - } else { - class_node.op_type = IS_UNUSED; + zend_ast *args_ast = zend_ast_call_get_args(callback); + if (args_ast->kind != ZEND_AST_CALLABLE_CONVERT) { + return FAILURE; } - /* Evaluate function name */ - znode func_node; if (callback->kind == ZEND_AST_CALL - && func_name_ast->kind == ZEND_AST_ZVAL - && Z_TYPE_P(zend_ast_get_zval(func_name_ast)) == IS_STRING) { - /* A literal function name has no side effects and must not be memoized: - * compiling it as an expression would yield the unresolved string, which - * ignores the current namespace, "use function" imports and the runtime - * fallback to the global function. Compile the call in the loop body with - * the original name instead, like a regular call. */ - func_node.op_type = IS_UNUSED; - } else { - znode result; - zend_compile_expr(&result, func_name_ast); - if (result.op_type == IS_CONST || result.op_type == IS_TMP_VAR) { - func_node = result; - } else { - zend_emit_op_tmp(&func_node, ZEND_QM_ASSIGN, &result, NULL); - } + && !zend_is_pipe_optimizable_callable_name(callback->child[0])) { + return FAILURE; } - if (class_node.op_type == IS_CONST - && func_node.op_type == IS_CONST - && Z_TYPE(func_node.u.constant) == IS_STRING) { - const zend_class_entry *ce = NULL; - uint32_t fetch_type = zend_get_class_fetch_type(Z_STR(class_node.u.constant)); - if (fetch_type == ZEND_FETCH_CLASS_DEFAULT) { - zend_string *ce_lcname = zend_string_tolower(Z_STR(class_node.u.constant)); - ce = zend_hash_find_ptr(CG(class_table), ce_lcname); - zend_string_release_ex(ce_lcname, 0); - if (ce) { - if (zend_compile_ignore_class(ce, CG(active_op_array)->filename)) { - ce = NULL; - } - } else if (CG(active_class_entry) - && zend_string_equals_ci(CG(active_class_entry)->name, Z_STR(class_node.u.constant))) { - ce = CG(active_class_entry); - } - } else if (fetch_type == ZEND_FETCH_CLASS_SELF && zend_is_scope_known()) { - ce = CG(active_class_entry); - } else if (fetch_type == ZEND_FETCH_CLASS_PARENT && zend_is_scope_known()) { - ce = zend_resolve_compile_time_parent(CG(active_class_entry)); - } - if (ce) { - zend_string *method_lcname = zend_string_tolower(Z_STR(func_node.u.constant)); - const zend_function *callee_fbc = NULL; - for (const zend_class_entry *cur_ce = ce; cur_ce && !callee_fbc; cur_ce = zend_resolve_compile_time_parent(cur_ce)) { - if (!zend_compile_ignore_class(cur_ce, CG(active_op_array)->filename)) { - callee_fbc = zend_get_compatible_func_or_null(cur_ce, method_lcname); - } - } - zend_string_release_ex(method_lcname, 0); - if (callee_fbc && (callee_fbc->common.fn_flags2 & ZEND_ACC2_FORBID_DYN_CALLS)) { - zval_ptr_dtor_nogc(&func_node.u.constant); - zval_ptr_dtor_nogc(&class_node.u.constant); - return FAILURE; - } - } + /* PFAs with non-literal pre-bound arguments are not optimizable because we + * can't memoize arguments without breaking pass-by-reference. Also require + * a statically known by-value callee before emitting any bytecode. */ + zend_ast_fcc *fcc = (zend_ast_fcc*)args_ast; + if (!zend_array_map_callback_is_optimizable(callback, zend_ast_get_list(fcc->args))) { + return FAILURE; } zend_op *opline; @@ -5616,56 +5526,8 @@ static zend_result zend_compile_func_array_map(znode *result, zend_ast_list *arg /* array is an argument to both ZEND_TYPE_ASSERT and to ZEND_FE_RESET_R. */ if (array.op_type == IS_CONST) { if (Z_TYPE(array.u.constant) != IS_ARRAY) { - if (class_node.op_type != IS_TMP_VAR && func_node.op_type != IS_TMP_VAR) { - zval_ptr_dtor_nogc(&array.u.constant); - if (func_node.op_type == IS_CONST) { - zval_ptr_dtor_nogc(&func_node.u.constant); - } - if (class_node.op_type == IS_CONST) { - zval_ptr_dtor_nogc(&class_node.u.constant); - } - return FAILURE; - } - - /* Callee subexpressions already emitted runtime opcodes into TMP_VARs; - * fall back to a regular array_map() call reusing them so nothing is - * evaluated twice or leaked. */ - zend_ast *func_ast = func_node.op_type == IS_UNUSED - ? func_name_ast - : zend_ast_create_znode(&func_node); - zend_ast *cb_ast; - if (callback->kind == ZEND_AST_CALL) { - cb_ast = zend_ast_create(ZEND_AST_CALL, func_ast, args_ast); - } else { - zend_ast *class_ast; - if (class_node.op_type == IS_CONST) { - zval_ptr_dtor_nogc(&class_node.u.constant); - class_ast = callback->child[0]; - } else { - class_ast = zend_ast_create_znode(&class_node); - } - cb_ast = zend_ast_create(ZEND_AST_STATIC_CALL, class_ast, func_ast, args_ast); - } - cb_ast->lineno = callback->lineno; - - znode fcall_name; - fcall_name.op_type = IS_CONST; - ZVAL_STR_COPY(&fcall_name.u.constant, lcname); - opline = zend_emit_op(NULL, ZEND_INIT_FCALL, NULL, &fcall_name); - opline->lineno = lineno; - opline->result.num = zend_alloc_cache_slot(); - - const zval *fbc_zv = zend_hash_find(CG(function_table), lcname); - const zend_function *array_map_fbc = Z_PTR_P(fbc_zv); - if (array_map_fbc->type == ZEND_INTERNAL_FUNCTION) { - const Bucket *fbc_bucket = ZEND_CONTAINER_OF(fbc_zv, Bucket, val); - Z_EXTRA_P(CT_CONSTANT(opline->op2)) = fbc_bucket - CG(function_table)->arData; - } - - zend_ast *fallback_args = zend_ast_create_list(2, ZEND_AST_ARG_LIST, - cb_ast, zend_ast_create_znode(&array)); - zend_compile_call_common(result, fallback_args, array_map_fbc, lineno, type); - return SUCCESS; + zval_ptr_dtor_nogc(&array.u.constant); + return FAILURE; } Z_TRY_ADDREF(array.u.constant); } @@ -5704,39 +5566,11 @@ static zend_result zend_compile_func_array_map(znode *result, zend_ast_list *arg /* loop body */ znode call_result; - zend_ast *func_ast; - if (func_node.op_type == IS_UNUSED) { - func_ast = func_name_ast; - } else if (func_node.op_type == IS_CONST) { - func_ast = zend_ast_create_znode(&func_node); - } else { - znode copy_node; - zend_emit_op_tmp(©_node, ZEND_COPY_TMP, &func_node, NULL); - func_ast = zend_ast_create_znode(©_node); - } - switch (callback->kind) { - case ZEND_AST_CALL: { - zend_compile_expr(&call_result, zend_ast_create(ZEND_AST_CALL, func_ast, call_args)); - break; - } - case ZEND_AST_STATIC_CALL: { - zend_ast *class_ast; - if (class_node.op_type == IS_CONST) { - class_ast = zend_ast_create_znode(&class_node); - } else { - znode copy_node; - zend_emit_op_tmp(©_node, ZEND_COPY_TMP, &class_node, NULL); - class_ast = zend_ast_create_znode(©_node); - } - - zend_compile_expr(&call_result, zend_ast_create(ZEND_AST_STATIC_CALL, class_ast, func_ast, call_args)); - zend_ast_destroy(class_ast); - break; - } - } - if (func_ast != func_name_ast) { - zend_ast_destroy(func_ast); - } + zend_ast *call_ast = callback->kind == ZEND_AST_CALL + ? zend_ast_create(ZEND_AST_CALL, callback->child[0], call_args) + : zend_ast_create(ZEND_AST_STATIC_CALL, callback->child[0], callback->child[1], call_args); + call_ast->lineno = callback->lineno; + zend_compile_expr(&call_result, call_ast); opline = zend_emit_op(NULL, ZEND_ADD_ARRAY_ELEMENT, &call_result, &key); SET_NODE(opline->result, result); /* end loop body */ @@ -5751,12 +5585,6 @@ static zend_result zend_compile_func_array_map(znode *result, zend_ast_list *arg zend_end_loop(opnum_fetch, &reset_node); zend_emit_op(NULL, ZEND_FE_FREE, &reset_node, NULL); - if (func_node.op_type != IS_UNUSED && func_node.op_type != IS_CONST) { - zend_emit_op(NULL, ZEND_FREE, &func_node, NULL); - } - if (class_node.op_type != IS_UNUSED && class_node.op_type != IS_CONST) { - zend_emit_op(NULL, ZEND_FREE, &class_node, NULL); - } return SUCCESS; } @@ -5827,7 +5655,7 @@ static zend_result zend_try_compile_special_func_ex(znode *result, zend_string * } else if (zend_string_equals(lcname, ZSTR_KNOWN(ZEND_STR_CLONE))) { return zend_compile_func_clone(result, args); } else if (zend_string_equals_literal(lcname, "array_map")) { - return zend_compile_func_array_map(result, args, lcname, lineno, type); + return zend_compile_func_array_map(result, args, lcname, lineno); } else { return FAILURE; }