From a9fd352df48ef2132caccd2ac65249c375a492c4 Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Fri, 23 Feb 2024 20:32:05 +0000 Subject: [PATCH] Zend: make exit/die a function instead of a language construct --- Zend/Optimizer/block_pass.c | 4 +- Zend/Optimizer/pass1.c | 1 - Zend/Optimizer/pass3.c | 3 +- Zend/Optimizer/zend_call_graph.c | 4 - Zend/Optimizer/zend_cfg.c | 2 - Zend/tests/arginfo_zpp_mismatch.inc | 3 + Zend/tests/exit/define_die_constant.phpt | 2 +- .../exit/define_die_constant_namespace.phpt | 2 +- Zend/tests/exit/define_die_function.phpt | 2 +- .../exit/define_die_function_namespace.phpt | 2 +- Zend/tests/exit/define_exit_constant.phpt | 2 +- .../exit/define_exit_constant_namespace.phpt | 2 +- Zend/tests/exit/define_exit_function.phpt | 2 +- .../exit/define_exit_function_namespace.phpt | 2 +- Zend/tests/exit/define_goto_label_die.phpt | 6 +- .../exit/define_goto_label_die_with_jump.phpt | 5 +- Zend/tests/exit/define_goto_label_exit.phpt | 6 +- .../define_goto_label_exit_with_jump.phpt | 5 +- .../tests/exit/die_string_cast_exception.phpt | 13 +- Zend/tests/exit/disabling_die.phpt | 1 + Zend/tests/exit/disabling_exit.phpt | 1 + Zend/tests/exit/exit_as_function.phpt | 23 +- Zend/tests/exit/exit_values.phpt | 44 +- Zend/zend_API.c | 7 + Zend/zend_builtin_functions.c | 23 + Zend/zend_builtin_functions.stub.php | 5 + Zend/zend_builtin_functions_arginfo.h | 11 +- Zend/zend_compile.c | 72 +- Zend/zend_language_parser.y | 11 +- Zend/zend_language_scanner.l | 8 - Zend/zend_string.h | 1 + Zend/zend_vm_def.h | 32 - Zend/zend_vm_execute.h | 421 ++-- Zend/zend_vm_handlers.h | 1925 ++++++++--------- Zend/zend_vm_opcodes.c | 2 +- Zend/zend_vm_opcodes.h | 1 - ext/ftp/tests/server.inc | 12 +- ext/opcache/jit/zend_jit.c | 2 - ext/opcache/jit/zend_jit_ir.c | 9 +- ext/opcache/jit/zend_jit_trace.c | 1 - ext/opcache/tests/jit/ignored_opcodes.phpt | 7 +- .../tests/array/array_filter_variation9.phpt | 6 +- .../tests/array/array_map_variation16.phpt | 44 +- ext/tokenizer/tests/001.phpt | 2 - ext/tokenizer/tokenizer_data.c | 1 - ext/tokenizer/tokenizer_data.stub.php | 5 - ext/tokenizer/tokenizer_data_arginfo.h | 3 +- sapi/phpdbg/phpdbg_prompt.c | 2 - 48 files changed, 1352 insertions(+), 1398 deletions(-) diff --git a/Zend/Optimizer/block_pass.c b/Zend/Optimizer/block_pass.c index cd6dce6a5c10a..6fcbd04f12af5 100644 --- a/Zend/Optimizer/block_pass.c +++ b/Zend/Optimizer/block_pass.c @@ -868,7 +868,6 @@ static void zend_optimize_block(zend_basic_block *block, zend_op_array *op_array break; case ZEND_RETURN: - case ZEND_EXIT: if (opline->op1_type == IS_TMP_VAR) { src = VAR_SOURCE(opline->op1); if (src && src->opcode == ZEND_QM_ASSIGN) { @@ -1221,8 +1220,7 @@ static void zend_jmp_optimization(zend_basic_block *block, zend_op_array *op_arr target = op_array->opcodes + target_block->start; if ((target->opcode == ZEND_RETURN || target->opcode == ZEND_RETURN_BY_REF || - target->opcode == ZEND_GENERATOR_RETURN || - target->opcode == ZEND_EXIT) && + target->opcode == ZEND_GENERATOR_RETURN) && !(op_array->fn_flags & ZEND_ACC_HAS_FINALLY_BLOCK)) { /* JMP L, L: RETURN to immediate RETURN */ *last_op = *target; diff --git a/Zend/Optimizer/pass1.c b/Zend/Optimizer/pass1.c index ba2bf188102c2..1353244300bc6 100644 --- a/Zend/Optimizer/pass1.c +++ b/Zend/Optimizer/pass1.c @@ -331,7 +331,6 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) case ZEND_RETURN: case ZEND_RETURN_BY_REF: case ZEND_GENERATOR_RETURN: - case ZEND_EXIT: case ZEND_THROW: case ZEND_MATCH_ERROR: case ZEND_CATCH: diff --git a/Zend/Optimizer/pass3.c b/Zend/Optimizer/pass3.c index 93e431fece440..2cbd0e3406521 100644 --- a/Zend/Optimizer/pass3.c +++ b/Zend/Optimizer/pass3.c @@ -88,8 +88,7 @@ void zend_optimizer_pass3(zend_op_array *op_array, zend_optimizer_ctx *ctx) MAKE_NOP(opline); } else if ((target->opcode == ZEND_RETURN || target->opcode == ZEND_RETURN_BY_REF || - target->opcode == ZEND_GENERATOR_RETURN || - target->opcode == ZEND_EXIT) && + target->opcode == ZEND_GENERATOR_RETURN) && !(op_array->fn_flags & ZEND_ACC_HAS_FINALLY_BLOCK)) { /* JMP L, L: RETURN to immediate RETURN */ *opline = *target; diff --git a/Zend/Optimizer/zend_call_graph.c b/Zend/Optimizer/zend_call_graph.c index 5db8d06674b59..d3f6652c1384f 100644 --- a/Zend/Optimizer/zend_call_graph.c +++ b/Zend/Optimizer/zend_call_graph.c @@ -161,10 +161,6 @@ ZEND_API void zend_analyze_calls(zend_arena **arena, zend_script *script, uint32 call_info->send_unpack = 1; } break; - case ZEND_EXIT: - /* In this case the DO_CALL opcode may have been dropped - * and caller_call_opline will be NULL. */ - break; } opline++; } diff --git a/Zend/Optimizer/zend_cfg.c b/Zend/Optimizer/zend_cfg.c index 4d3d62137b9e3..92db5b5b0d6b2 100644 --- a/Zend/Optimizer/zend_cfg.c +++ b/Zend/Optimizer/zend_cfg.c @@ -303,7 +303,6 @@ ZEND_API void zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, } break; case ZEND_MATCH_ERROR: - case ZEND_EXIT: case ZEND_THROW: /* Don't treat THROW as terminator if it's used in expression context, * as we may lose live ranges when eliminating unreachable code. */ @@ -507,7 +506,6 @@ ZEND_API void zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, case ZEND_RETURN: case ZEND_RETURN_BY_REF: case ZEND_GENERATOR_RETURN: - case ZEND_EXIT: case ZEND_THROW: case ZEND_MATCH_ERROR: case ZEND_VERIFY_NEVER_TYPE: diff --git a/Zend/tests/arginfo_zpp_mismatch.inc b/Zend/tests/arginfo_zpp_mismatch.inc index 023bfefa5d501..5b2711fdb6303 100644 --- a/Zend/tests/arginfo_zpp_mismatch.inc +++ b/Zend/tests/arginfo_zpp_mismatch.inc @@ -6,6 +6,9 @@ function skipFunction($function): bool { || $function === 'readline' || $function === 'readline_read_history' || $function === 'readline_write_history' + /* terminates script */ + || $function === 'exit' + || $function === 'die' /* intentionally violate invariants */ || $function === 'zend_create_unterminated_string' || $function === 'zend_test_array_return' diff --git a/Zend/tests/exit/define_die_constant.phpt b/Zend/tests/exit/define_die_constant.phpt index 393904d9356dd..abdb6cf2729c8 100644 --- a/Zend/tests/exit/define_die_constant.phpt +++ b/Zend/tests/exit/define_die_constant.phpt @@ -9,4 +9,4 @@ var_dump(die); ?> --EXPECTF-- -Parse error: syntax error, unexpected token "exit", expecting identifier in %s on line %d +Fatal error: Cannot define constant with name die in %s on line %d diff --git a/Zend/tests/exit/define_die_constant_namespace.phpt b/Zend/tests/exit/define_die_constant_namespace.phpt index b68038ba10fb7..71f63ce2841a4 100644 --- a/Zend/tests/exit/define_die_constant_namespace.phpt +++ b/Zend/tests/exit/define_die_constant_namespace.phpt @@ -11,4 +11,4 @@ var_dump(die); ?> --EXPECTF-- -Parse error: syntax error, unexpected token "exit", expecting identifier in %s on line %d +Fatal error: Cannot define constant with name die in %s on line %d diff --git a/Zend/tests/exit/define_die_function.phpt b/Zend/tests/exit/define_die_function.phpt index 4ea41d6ced5bd..d3068cae1c0b0 100644 --- a/Zend/tests/exit/define_die_function.phpt +++ b/Zend/tests/exit/define_die_function.phpt @@ -7,4 +7,4 @@ function die() { } ?> --EXPECTF-- -Parse error: syntax error, unexpected token "exit", expecting "(" in %s on line %d +Fatal error: Defining a custom die() function is not allowed, as the function has special semantics in %s on line %d diff --git a/Zend/tests/exit/define_die_function_namespace.phpt b/Zend/tests/exit/define_die_function_namespace.phpt index fece46cb7acd6..72bb942d984e8 100644 --- a/Zend/tests/exit/define_die_function_namespace.phpt +++ b/Zend/tests/exit/define_die_function_namespace.phpt @@ -11,4 +11,4 @@ var_dump(die()); ?> --EXPECTF-- -Parse error: syntax error, unexpected token "exit", expecting "(" in %s on line %d +Fatal error: Defining a custom die() function is not allowed, as the function has special semantics in %s on line %d diff --git a/Zend/tests/exit/define_exit_constant.phpt b/Zend/tests/exit/define_exit_constant.phpt index 33cd073401223..a0539ef9328f6 100644 --- a/Zend/tests/exit/define_exit_constant.phpt +++ b/Zend/tests/exit/define_exit_constant.phpt @@ -9,4 +9,4 @@ var_dump(exit); ?> --EXPECTF-- -Parse error: syntax error, unexpected token "exit", expecting identifier in %s on line %d +Fatal error: Cannot define constant with name exit in %s on line %d diff --git a/Zend/tests/exit/define_exit_constant_namespace.phpt b/Zend/tests/exit/define_exit_constant_namespace.phpt index 8d0097bb9da3c..9cb3059e5d7ce 100644 --- a/Zend/tests/exit/define_exit_constant_namespace.phpt +++ b/Zend/tests/exit/define_exit_constant_namespace.phpt @@ -11,4 +11,4 @@ var_dump(exit); ?> --EXPECTF-- -Parse error: syntax error, unexpected token "exit", expecting identifier in %s on line %d +Fatal error: Cannot define constant with name exit in %s on line %d diff --git a/Zend/tests/exit/define_exit_function.phpt b/Zend/tests/exit/define_exit_function.phpt index 4c406ef0d8905..13c771962059c 100644 --- a/Zend/tests/exit/define_exit_function.phpt +++ b/Zend/tests/exit/define_exit_function.phpt @@ -7,4 +7,4 @@ function exit() { } ?> --EXPECTF-- -Parse error: syntax error, unexpected token "exit", expecting "(" in %s on line %d +Fatal error: Defining a custom exit() function is not allowed, as the function has special semantics in %s on line %d diff --git a/Zend/tests/exit/define_exit_function_namespace.phpt b/Zend/tests/exit/define_exit_function_namespace.phpt index 9ea785b0e53ba..5ed72a9b02c7a 100644 --- a/Zend/tests/exit/define_exit_function_namespace.phpt +++ b/Zend/tests/exit/define_exit_function_namespace.phpt @@ -9,4 +9,4 @@ function exit() { } ?> --EXPECTF-- -Parse error: syntax error, unexpected token "exit", expecting "(" in %s on line %d +Fatal error: Defining a custom exit() function is not allowed, as the function has special semantics in %s on line %d diff --git a/Zend/tests/exit/define_goto_label_die.phpt b/Zend/tests/exit/define_goto_label_die.phpt index b94ee13fa0abe..4ab31f6cd5590 100644 --- a/Zend/tests/exit/define_goto_label_die.phpt +++ b/Zend/tests/exit/define_goto_label_die.phpt @@ -10,5 +10,7 @@ die: echo "After\n"; ?> ---EXPECTF-- -Parse error: syntax error, unexpected token ":" in %s on line %d +--EXPECT-- +Before +In between +After diff --git a/Zend/tests/exit/define_goto_label_die_with_jump.phpt b/Zend/tests/exit/define_goto_label_die_with_jump.phpt index fc755d52a5794..b442723ff316d 100644 --- a/Zend/tests/exit/define_goto_label_die_with_jump.phpt +++ b/Zend/tests/exit/define_goto_label_die_with_jump.phpt @@ -10,5 +10,6 @@ die: echo "After\n"; ?> ---EXPECTF-- -Parse error: syntax error, unexpected token "exit", expecting identifier in %s on line %d +--EXPECT-- +Before +After diff --git a/Zend/tests/exit/define_goto_label_exit.phpt b/Zend/tests/exit/define_goto_label_exit.phpt index a72b6bac2d2a4..76f00b3307a60 100644 --- a/Zend/tests/exit/define_goto_label_exit.phpt +++ b/Zend/tests/exit/define_goto_label_exit.phpt @@ -10,5 +10,7 @@ exit: echo "After\n"; ?> ---EXPECTF-- -Parse error: syntax error, unexpected token ":" in %s on line %d +--EXPECT-- +Before +In between +After diff --git a/Zend/tests/exit/define_goto_label_exit_with_jump.phpt b/Zend/tests/exit/define_goto_label_exit_with_jump.phpt index a810f2c44c2d8..c3d87ddceff04 100644 --- a/Zend/tests/exit/define_goto_label_exit_with_jump.phpt +++ b/Zend/tests/exit/define_goto_label_exit_with_jump.phpt @@ -10,5 +10,6 @@ exit: echo "After\n"; ?> ---EXPECTF-- -Parse error: syntax error, unexpected token "exit", expecting identifier in %s on line %d +--EXPECT-- +Before +After diff --git a/Zend/tests/exit/die_string_cast_exception.phpt b/Zend/tests/exit/die_string_cast_exception.phpt index 9893c3389f970..a1892ed3cb07b 100644 --- a/Zend/tests/exit/die_string_cast_exception.phpt +++ b/Zend/tests/exit/die_string_cast_exception.phpt @@ -3,11 +3,12 @@ Bug #79777: String cast exception during die should be handled gracefully --FILE-- getMessage(), PHP_EOL; +} ?> ---EXPECTF-- -Fatal error: Uncaught Error: Object of class stdClass could not be converted to string in %s:%d -Stack trace: -#0 {main} - thrown in %s on line %d +--EXPECT-- +die(): Argument #1 ($code) must be of type string|int, stdClass given diff --git a/Zend/tests/exit/disabling_die.phpt b/Zend/tests/exit/disabling_die.phpt index 85a3d6daa8ef9..8d84067a9abda 100644 --- a/Zend/tests/exit/disabling_die.phpt +++ b/Zend/tests/exit/disabling_die.phpt @@ -9,3 +9,4 @@ die(); ?> --EXPECT-- +Warning: Cannot disable function die() in Unknown on line 0 diff --git a/Zend/tests/exit/disabling_exit.phpt b/Zend/tests/exit/disabling_exit.phpt index fb72226a98518..a6cf277d38f72 100644 --- a/Zend/tests/exit/disabling_exit.phpt +++ b/Zend/tests/exit/disabling_exit.phpt @@ -9,3 +9,4 @@ exit(); ?> --EXPECT-- +Warning: Cannot disable function exit() in Unknown on line 0 diff --git a/Zend/tests/exit/exit_as_function.phpt b/Zend/tests/exit/exit_as_function.phpt index c1487da7ed841..68a62ce1945c7 100644 --- a/Zend/tests/exit/exit_as_function.phpt +++ b/Zend/tests/exit/exit_as_function.phpt @@ -19,5 +19,24 @@ foreach ($values as $value) { } ?> ---EXPECTF-- -Parse error: syntax error, unexpected token "...", expecting ")" in %s on line %d +--EXPECT-- +string(4) "exit" +string(3) "die" +object(Closure)#1 (2) { + ["function"]=> + string(4) "exit" + ["parameter"]=> + array(1) { + ["$code"]=> + string(10) "" + } +} +object(Closure)#2 (2) { + ["function"]=> + string(3) "die" + ["parameter"]=> + array(1) { + ["$code"]=> + string(10) "" + } +} diff --git a/Zend/tests/exit/exit_values.phpt b/Zend/tests/exit/exit_values.phpt index 2f53a870f9fe1..5a7e8a00fda7a 100644 --- a/Zend/tests/exit/exit_values.phpt +++ b/Zend/tests/exit/exit_values.phpt @@ -80,15 +80,15 @@ const FILE_PATH = __DIR__ . '/exit_values.inc'; Using NULL as value: Exit status is: 0 Output is: - +Deprecated: exit(): Passing null to parameter #1 ($code) of type string|int is deprecated in %s on line %d Using false as value: Exit status is: 0 Output is: Using true as value: -Exit status is: 0 +Exit status is: 1 Output is: -1 + Using 0 as value: Exit status is: 0 Output is: @@ -102,13 +102,13 @@ Exit status is: 20 Output is: Using 10.0 as value: -Exit status is: 0 +Exit status is: 10 Output is: -10 + Using 15.5 as value: -Exit status is: 0 +Exit status is: 15 Output is: -15.5 +Deprecated: Implicit conversion from float 15.5 to int loses precision in %s on line %d Using 'Hello world' as value: Exit status is: 0 Output is: @@ -116,31 +116,31 @@ Hello world Using [] as value: Exit status is: 0 Output is: -Warning: Array to string conversion in %s on line 3Array +TypeError: exit(): Argument #1 ($code) must be of type string|int, array given Using STDERR as value: Exit status is: 0 Output is: -Resource id #3 +TypeError: exit(): Argument #1 ($code) must be of type string|int, resource given Using new stdClass() as value: Exit status is: 0 Output is: -Error: Object of class stdClass could not be converted to string +TypeError: exit(): Argument #1 ($code) must be of type string|int, stdClass given As a statement: Exit status is: 0 Output is: -Error: Object of class stdClass could not be converted to string +TypeError: exit(): Argument #1 ($code) must be of type string|int, stdClass given Using NULL as value: Exit status is: 0 Output is: - +Deprecated: die(): Passing null to parameter #1 ($code) of type string|int is deprecated in %s on line %d Using false as value: Exit status is: 0 Output is: Using true as value: -Exit status is: 0 +Exit status is: 1 Output is: -1 + Using 0 as value: Exit status is: 0 Output is: @@ -154,13 +154,13 @@ Exit status is: 20 Output is: Using 10.0 as value: -Exit status is: 0 +Exit status is: 10 Output is: -10 + Using 15.5 as value: -Exit status is: 0 +Exit status is: 15 Output is: -15.5 +Deprecated: Implicit conversion from float 15.5 to int loses precision in %s on line %d Using 'Hello world' as value: Exit status is: 0 Output is: @@ -168,16 +168,16 @@ Hello world Using [] as value: Exit status is: 0 Output is: -Warning: Array to string conversion in %s on line 3Array +TypeError: die(): Argument #1 ($code) must be of type string|int, array given Using STDERR as value: Exit status is: 0 Output is: -Resource id #3 +TypeError: die(): Argument #1 ($code) must be of type string|int, resource given Using new stdClass() as value: Exit status is: 0 Output is: -Error: Object of class stdClass could not be converted to string +TypeError: die(): Argument #1 ($code) must be of type string|int, stdClass given As a statement: Exit status is: 0 Output is: -Error: Object of class stdClass could not be converted to string +TypeError: die(): Argument #1 ($code) must be of type string|int, stdClass given diff --git a/Zend/zend_API.c b/Zend/zend_API.c index ae7a06f011761..bfbfe6d4ecea8 100644 --- a/Zend/zend_API.c +++ b/Zend/zend_API.c @@ -3541,6 +3541,13 @@ ZEND_API zend_result zend_set_hash_symbol(zval *symbol, const char *name, size_t static void zend_disable_function(const char *function_name, size_t function_name_length) { + if (UNEXPECTED( + (function_name_length == strlen("exit") && !memcmp(function_name, "exit", strlen("exit"))) + || (function_name_length == strlen("die") && !memcmp(function_name, "die", strlen("die"))) + )) { + zend_error(E_WARNING, "Cannot disable function %s()", function_name); + return; + } zend_hash_str_del(CG(function_table), function_name, function_name_length); } diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c index 337e5483613d1..95c9eefe09a5a 100644 --- a/Zend/zend_builtin_functions.c +++ b/Zend/zend_builtin_functions.c @@ -69,6 +69,29 @@ zend_result zend_startup_builtin_functions(void) /* {{{ */ } /* }}} */ +ZEND_FUNCTION(exit) +{ + zend_string *str = NULL; + zend_long code = 0; + + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_STR_OR_LONG(str, code) + ZEND_PARSE_PARAMETERS_END(); + + if (str) { + size_t len = ZSTR_LEN(str); + if (len != 0) { + zend_write(ZSTR_VAL(str), len); + } + } else { + EG(exit_status) = code; + } + + ZEND_ASSERT(!EG(exception)); + zend_throw_unwind_exit(); +} + /* {{{ Get the version of the Zend Engine */ ZEND_FUNCTION(zend_version) { diff --git a/Zend/zend_builtin_functions.stub.php b/Zend/zend_builtin_functions.stub.php index b92b80b917c54..ddf12e117966f 100644 --- a/Zend/zend_builtin_functions.stub.php +++ b/Zend/zend_builtin_functions.stub.php @@ -7,6 +7,11 @@ class stdClass { } +function exit(string|int $code = 0): never {} + +/** @alias exit */ +function die(string|int $code = 0): never {} + /** @refcount 1 */ function zend_version(): string {} diff --git a/Zend/zend_builtin_functions_arginfo.h b/Zend/zend_builtin_functions_arginfo.h index 20e6f0f9b48a3..db9f325c63f00 100644 --- a/Zend/zend_builtin_functions_arginfo.h +++ b/Zend/zend_builtin_functions_arginfo.h @@ -1,5 +1,11 @@ /* This is a generated file, edit the .stub.php file instead. - * Stub hash: c3bec3b17079456ef17e5c992995dcfbe62c6fe0 */ + * Stub hash: a6d7e59d6b7875ddc28ce828ae240c7dfd852023 */ + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_exit, 0, 0, IS_NEVER, 0) + ZEND_ARG_TYPE_MASK(0, code, MAY_BE_STRING|MAY_BE_LONG, "0") +ZEND_END_ARG_INFO() + +#define arginfo_die arginfo_exit ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zend_version, 0, 0, IS_STRING, 0) ZEND_END_ARG_INFO() @@ -232,6 +238,7 @@ static const zend_frameless_function_info frameless_function_infos_class_exists[ { 0 }, }; +ZEND_FUNCTION(exit); ZEND_FUNCTION(zend_version); ZEND_FUNCTION(func_num_args); ZEND_FUNCTION(func_get_arg); @@ -292,6 +299,8 @@ ZEND_FUNCTION(gc_disable); ZEND_FUNCTION(gc_status); static const zend_function_entry ext_functions[] = { + ZEND_FE(exit, arginfo_exit) + ZEND_RAW_FENTRY("die", zif_exit, arginfo_die, 0, NULL, NULL) ZEND_FE(zend_version, arginfo_zend_version) ZEND_FE(func_num_args, arginfo_func_num_args) ZEND_FE(func_get_arg, arginfo_func_get_arg) diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index ae2247b29e30d..cf3f02610b1dd 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -7714,7 +7714,7 @@ static zend_string *zend_begin_func_decl(znode *result, zend_op_array *op_array, zend_string *separator = zend_empty_string; zend_string *function = filename; char *parens = ""; - + if (CG(active_op_array) && CG(active_op_array)->function_name) { if (CG(active_op_array)->fn_flags & ZEND_ACC_CLOSURE) { /* If the parent function is a closure, don't redundantly @@ -7764,10 +7764,14 @@ static zend_string *zend_begin_func_decl(znode *result, zend_op_array *op_array, "__autoload() is no longer supported, use spl_autoload_register() instead"); } - if (zend_string_equals_literal_ci(unqualified_name, "assert")) { + if ( + zend_string_equals_literal_ci(unqualified_name, "assert") + || zend_string_equals_literal_ci(unqualified_name, "exit") + || zend_string_equals_literal_ci(unqualified_name, "die") + ) { zend_error(E_COMPILE_ERROR, - "Defining a custom assert() function is not allowed, " - "as the function has special semantics"); + "Defining a custom %s() function is not allowed, " + "as the function has special semantics", ZSTR_VAL(unqualified_name)); } zend_register_seen_symbol(lcname, ZEND_SYMBOL_FUNCTION); @@ -8710,6 +8714,13 @@ static void zend_compile_const_decl(zend_ast *ast) /* {{{ */ value_node.op_type = IS_CONST; zend_const_expr_to_zval(value_zv, value_ast_ptr, /* allow_dynamic */ true); + if (UNEXPECTED( + zend_string_equals_literal_ci(unqualified_name, "exit") + || zend_string_equals_literal_ci(unqualified_name, "die") + )) { + zend_throw_error(NULL, "Cannot define constant with name %s", ZSTR_VAL(unqualified_name)); + return; + } if (zend_get_special_const(ZSTR_VAL(unqualified_name), ZSTR_LEN(unqualified_name))) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare constant '%s'", ZSTR_VAL(unqualified_name)); @@ -9702,27 +9713,6 @@ static void zend_compile_print(znode *result, zend_ast *ast) /* {{{ */ } /* }}} */ -static void zend_compile_exit(znode *result, zend_ast *ast) /* {{{ */ -{ - zend_ast *expr_ast = ast->child[0]; - znode expr_node; - - if (expr_ast) { - zend_compile_expr(&expr_node, expr_ast); - } else { - expr_node.op_type = IS_UNUSED; - } - - zend_op *opline = zend_emit_op(NULL, ZEND_EXIT, &expr_node, NULL); - if (result) { - /* Mark this as an "expression throw" for opcache. */ - opline->extended_value = ZEND_THROW_IS_EXPR; - result->op_type = IS_CONST; - ZVAL_TRUE(&result->u.constant); - } -} -/* }}} */ - static void zend_compile_yield(znode *result, zend_ast *ast) /* {{{ */ { zend_ast *value_ast = ast->child[0]; @@ -10026,6 +10016,34 @@ static void zend_compile_const(znode *result, zend_ast *ast) /* {{{ */ bool is_fully_qualified; zend_string *orig_name = zend_ast_get_str(name_ast); + + /* The fake "constants" exit and die must be converted to a function call for exit() */ + if (UNEXPECTED( + zend_string_equals_literal_ci(orig_name, "exit") + || zend_string_equals_literal_ci(orig_name, "die") + )) { + zval *fbc_zv = zend_hash_find(CG(function_table), ZSTR_KNOWN(ZEND_STR_EXIT)); + ZEND_ASSERT(fbc_zv && "exit() function should always exist"); + zend_function *fbc = Z_PTR_P(fbc_zv); + + znode name_node; + name_node.op_type = IS_CONST; + ZVAL_STR(&name_node.u.constant, ZSTR_KNOWN(ZEND_STR_EXIT)); + + opline = zend_emit_op(NULL, ZEND_INIT_FCALL, NULL, &name_node); + opline->result.num = zend_alloc_cache_slot(); + + /* Store offset to function from symbol table in op2.extra. */ + { + Bucket *fbc_bucket = (Bucket*)((uintptr_t)fbc_zv - XtOffsetOf(Bucket, val)); + Z_EXTRA_P(CT_CONSTANT(opline->op2)) = fbc_bucket - CG(function_table)->arData; + } + + zend_ast *args_list = zend_ast_create_list_0(ZEND_AST_ARG_LIST); + zend_compile_call_common(result, args_list, fbc, ast->lineno); + return; + } + zend_string *resolved_name = zend_resolve_const_name(orig_name, name_ast->attr, &is_fully_qualified); if (zend_string_equals_literal(resolved_name, "__COMPILER_HALT_OFFSET__") || (name_ast->attr != ZEND_NAME_RELATIVE && zend_string_equals_literal(orig_name, "__COMPILER_HALT_OFFSET__"))) { @@ -10684,7 +10702,6 @@ static void zend_compile_stmt(zend_ast *ast) /* {{{ */ zend_compile_halt_compiler(ast); break; case ZEND_AST_THROW: - case ZEND_AST_EXIT: zend_compile_expr(NULL, ast); break; default: @@ -10786,9 +10803,6 @@ static void zend_compile_expr_inner(znode *result, zend_ast *ast) /* {{{ */ case ZEND_AST_PRINT: zend_compile_print(result, ast); return; - case ZEND_AST_EXIT: - zend_compile_exit(result, ast); - return; case ZEND_AST_YIELD: zend_compile_yield(result, ast); return; diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y index 6e882f922f374..e07356e631256 100644 --- a/Zend/zend_language_parser.y +++ b/Zend/zend_language_parser.y @@ -113,7 +113,6 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %token T_INSTANCEOF "'instanceof'" %token T_NEW "'new'" %token T_CLONE "'clone'" -%token T_EXIT "'exit'" %token T_IF "'if'" %token T_ELSEIF "'elseif'" %token T_ELSE "'else'" @@ -257,7 +256,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %type absolute_trait_method_reference trait_method_reference property echo_expr %type new_expr anonymous_class class_name class_name_reference simple_variable %type internal_functions_in_yacc -%type exit_expr scalar backticks_expr lexical_var function_call member_name property_name +%type scalar backticks_expr lexical_var function_call member_name property_name %type variable_class_name dereferenceable_scalar constant class_constant %type fully_dereferenceable array_object_dereferenceable %type callable_expr callable_variable static_member new_variable @@ -297,7 +296,7 @@ start: reserved_non_modifiers: T_INCLUDE | T_INCLUDE_ONCE | T_EVAL | T_REQUIRE | T_REQUIRE_ONCE | T_LOGICAL_OR | T_LOGICAL_XOR | T_LOGICAL_AND - | T_INSTANCEOF | T_NEW | T_CLONE | T_EXIT | T_IF | T_ELSEIF | T_ELSE | T_ENDIF | T_ECHO | T_DO | T_WHILE | T_ENDWHILE + | T_INSTANCEOF | T_NEW | T_CLONE | T_IF | T_ELSEIF | T_ELSE | T_ENDIF | T_ECHO | T_DO | T_WHILE | T_ENDWHILE | T_FOR | T_ENDFOR | T_FOREACH | T_ENDFOREACH | T_DECLARE | T_ENDDECLARE | T_AS | T_TRY | T_CATCH | T_FINALLY | T_THROW | T_USE | T_INSTEADOF | T_GLOBAL | T_VAR | T_UNSET | T_ISSET | T_EMPTY | T_CONTINUE | T_GOTO | T_FUNCTION | T_CONST | T_RETURN | T_PRINT | T_YIELD | T_LIST | T_SWITCH | T_ENDSWITCH | T_CASE | T_DEFAULT | T_BREAK @@ -1240,7 +1239,6 @@ expr: | T_OBJECT_CAST expr { $$ = zend_ast_create_cast(IS_OBJECT, $2); } | T_BOOL_CAST expr { $$ = zend_ast_create_cast(_IS_BOOL, $2); } | T_UNSET_CAST expr { $$ = zend_ast_create_cast(IS_NULL, $2); } - | T_EXIT exit_expr { $$ = zend_ast_create(ZEND_AST_EXIT, $2); } | '@' expr { $$ = zend_ast_create(ZEND_AST_SILENCE, $2); } | scalar { $$ = $1; } | '`' backticks_expr '`' { $$ = zend_ast_create(ZEND_AST_SHELL_EXEC, $2); } @@ -1343,11 +1341,6 @@ class_name_reference: | '(' expr ')' { $$ = $2; } ; -exit_expr: - %empty { $$ = NULL; } - | '(' optional_expr ')' { $$ = $2; } -; - backticks_expr: %empty { $$ = zend_ast_create_zval_from_str(ZSTR_EMPTY_ALLOC()); } diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l index 054ed7bdc1ef6..23ae98045b500 100644 --- a/Zend/zend_language_scanner.l +++ b/Zend/zend_language_scanner.l @@ -1382,14 +1382,6 @@ OPTIONAL_WHITESPACE_OR_COMMENTS ({WHITESPACE}|{MULTI_LINE_COMMENT}|{SINGLE_LINE_ /* compute yyleng before each rule */ := yyleng = YYCURSOR - SCNG(yy_text); -"exit" { - RETURN_TOKEN_WITH_IDENT(T_EXIT); -} - -"die" { - RETURN_TOKEN_WITH_IDENT(T_EXIT); -} - "fn" { RETURN_TOKEN_WITH_IDENT(T_FN); } diff --git a/Zend/zend_string.h b/Zend/zend_string.h index 2be7e7d267224..c576e0993af4e 100644 --- a/Zend/zend_string.h +++ b/Zend/zend_string.h @@ -572,6 +572,7 @@ EMPTY_SWITCH_DEFAULT_CASE() _(ZEND_STR_ARGS, "args") \ _(ZEND_STR_UNKNOWN, "unknown") \ _(ZEND_STR_UNKNOWN_CAPITALIZED, "Unknown") \ + _(ZEND_STR_EXIT, "exit") \ _(ZEND_STR_EVAL, "eval") \ _(ZEND_STR_INCLUDE, "include") \ _(ZEND_STR_REQUIRE, "require") \ diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index bedd328332dd1..02abc519ffe3f 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -7537,38 +7537,6 @@ ZEND_VM_C_LABEL(array_key_exists_array): ZEND_VM_SMART_BRANCH(result, 1); } -/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */ -ZEND_VM_COLD_HANDLER(79, ZEND_EXIT, ANY, ANY) -{ - USE_OPLINE - - SAVE_OPLINE(); - if (OP1_TYPE != IS_UNUSED) { - zval *ptr = GET_OP1_ZVAL_PTR(BP_VAR_R); - - do { - if (Z_TYPE_P(ptr) == IS_LONG) { - EG(exit_status) = Z_LVAL_P(ptr); - } else { - if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(ptr)) { - ptr = Z_REFVAL_P(ptr); - if (Z_TYPE_P(ptr) == IS_LONG) { - EG(exit_status) = Z_LVAL_P(ptr); - break; - } - } - zend_print_zval(ptr, 0); - } - } while (0); - FREE_OP1(); - } - - if (!EG(exception)) { - zend_throw_unwind_exit(); - } - HANDLE_EXCEPTION(); -} - ZEND_VM_HANDLER(57, ZEND_BEGIN_SILENCE, ANY, ANY) { USE_OPLINE diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 61631bc492f4d..8f244a350cc6b 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -2973,37 +2973,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXIT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - - SAVE_OPLINE(); - if (opline->op1_type != IS_UNUSED) { - zval *ptr = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R); - - do { - if (Z_TYPE_P(ptr) == IS_LONG) { - EG(exit_status) = Z_LVAL_P(ptr); - } else { - if ((opline->op1_type & (IS_VAR|IS_CV)) && Z_ISREF_P(ptr)) { - ptr = Z_REFVAL_P(ptr); - if (Z_TYPE_P(ptr) == IS_LONG) { - EG(exit_status) = Z_LVAL_P(ptr); - break; - } - } - zend_print_zval(ptr, 0); - } - } while (0); - FREE_OP(opline->op1_type, opline->op1.var); - } - - if (!EG(exception)) { - zend_throw_unwind_exit(); - } - HANDLE_EXCEPTION(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -7711,7 +7680,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CO ZEND_VM_SMART_BRANCH(result, 1); } -/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -10043,7 +10011,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TM ZEND_VM_SMART_BRANCH(result, 1); } -/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -12428,7 +12395,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV ZEND_VM_SMART_BRANCH(result, 1); } -/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -16549,7 +16515,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_C ZEND_VM_SMART_BRANCH(result, 1); } -/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -17967,7 +17932,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_T ZEND_VM_SMART_BRANCH(result, 1); } -/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -19326,7 +19290,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_C ZEND_VM_SMART_BRANCH(result, 1); } -/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -44283,7 +44246,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST ZEND_VM_SMART_BRANCH(result, 1); } -/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -47926,7 +47888,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVA ZEND_VM_SMART_BRANCH(result, 1); } -/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -53410,7 +53371,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HA ZEND_VM_SMART_BRANCH(result, 1); } -/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -55209,7 +55169,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FE_RESET_R_SPEC_CV_LABEL, (void*)&&ZEND_FE_FETCH_R_SPEC_VAR_LABEL, - (void*)&&ZEND_EXIT_SPEC_LABEL, (void*)&&ZEND_FETCH_R_SPEC_CONST_UNUSED_LABEL, (void*)&&ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_LABEL, (void*)&&ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_LABEL, @@ -57454,11 +57413,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) HYBRID_BREAK(); - HYBRID_CASE(ZEND_EXIT_SPEC): - VM_TRACE(ZEND_EXIT_SPEC) - ZEND_EXIT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_EXIT_SPEC) - HYBRID_BREAK(); HYBRID_CASE(ZEND_BEGIN_SILENCE_SPEC): VM_TRACE(ZEND_BEGIN_SILENCE_SPEC) ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -64372,7 +64326,6 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_FE_RESET_R_SPEC_CV_HANDLER, ZEND_FE_FETCH_R_SPEC_VAR_HANDLER, - ZEND_EXIT_SPEC_HANDLER, ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER, @@ -66312,7 +66265,7 @@ void zend_vm_init(void) 1255, 1256 | SPEC_RULE_OP1, 1261 | SPEC_RULE_OP1, - 3482, + 3481, 1266 | SPEC_RULE_OP1, 1271 | SPEC_RULE_OP1, 1276 | SPEC_RULE_OP2, @@ -66346,100 +66299,101 @@ void zend_vm_init(void) 1559 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 1584 | SPEC_RULE_OP1, 1589, - 1590, - 1591 | SPEC_RULE_OP1, - 1596 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1621 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1646 | SPEC_RULE_OP1, - 1651 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1676 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1701 | SPEC_RULE_OP1, - 1706 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1731 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1756 | SPEC_RULE_OP1, - 1761 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1786 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1811 | SPEC_RULE_OP1, - 1816 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1841 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1866 | SPEC_RULE_OP1, - 1871 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1896 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1921 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1946, - 1947 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 3481, + 1590 | SPEC_RULE_OP1, + 1595 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1620 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1645 | SPEC_RULE_OP1, + 1650 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1675 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1700 | SPEC_RULE_OP1, + 1705 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1730 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1755 | SPEC_RULE_OP1, + 1760 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1785 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1810 | SPEC_RULE_OP1, + 1815 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1840 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1865 | SPEC_RULE_OP1, + 1870 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1895 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1920 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1945, + 1946 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 1956, 1957, 1958, 1959, 1960, - 1961, - 1962 | SPEC_RULE_OP2, - 1967, - 1968 | SPEC_RULE_OP1, - 1973 | SPEC_RULE_OP2, - 1978 | SPEC_RULE_OP1, - 1983 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, - 1993 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2018 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2043 | SPEC_RULE_OP1, - 2048 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2073 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, - 2123 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2148 | SPEC_RULE_OP2, - 2153, - 2154 | SPEC_RULE_OP1, - 2159 | SPEC_RULE_OP1, - 2164, - 2165 | SPEC_RULE_OP1, - 2170 | SPEC_RULE_OP1, - 2175 | SPEC_RULE_OP1, + 1961 | SPEC_RULE_OP2, + 1966, + 1967 | SPEC_RULE_OP1, + 1972 | SPEC_RULE_OP2, + 1977 | SPEC_RULE_OP1, + 1982 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 1992 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2017 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2042 | SPEC_RULE_OP1, + 2047 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2072 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 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, - 2182 | SPEC_RULE_OP2, - 2187 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, - 2191 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, - 2195 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, - 2199 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2199 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2224 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2224 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2249 | SPEC_RULE_OP1, - 2254, - 2255 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2280, - 2281 | SPEC_RULE_OP1, + 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, - 2293 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2292 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2317, 2318, 2319, - 2320, - 2321 | SPEC_RULE_OP1, - 2326, - 2327 | SPEC_RULE_ISSET, - 2329 | SPEC_RULE_OP2, - 2334, - 2335 | SPEC_RULE_OP1, - 2340 | SPEC_RULE_OBSERVER, - 2342, - 2343 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2368 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 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, - 2382 | SPEC_RULE_OP1, + 2381 | SPEC_RULE_OP1, + 2386, 2387, - 2388, - 2389 | SPEC_RULE_OP1, - 2394 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2419, - 2420 | SPEC_RULE_OP1, + 2388 | SPEC_RULE_OP1, + 2393 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2418, + 2419 | SPEC_RULE_OP1, + 2424, 2425, 2426, 2427, @@ -66447,25 +66401,25 @@ void zend_vm_init(void) 2429, 2430, 2431, - 2432, - 2433 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2432 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2457, 2458, 2459, - 2460, - 2461 | SPEC_RULE_OP2, - 2466, - 2467 | SPEC_RULE_OP1, - 2472 | SPEC_RULE_OP1, - 2477 | SPEC_RULE_OP1, - 2482 | SPEC_RULE_OP1, - 2487 | SPEC_RULE_OP1, - 2492, - 2493 | SPEC_RULE_OP1, - 2498 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2523 | SPEC_RULE_OP1, - 2528 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2553 | SPEC_RULE_OP1, - 2558 | SPEC_RULE_OP1, + 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, + 2492 | SPEC_RULE_OP1, + 2497 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2522 | SPEC_RULE_OP1, + 2527 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2552 | SPEC_RULE_OP1, + 2557 | SPEC_RULE_OP1, + 2562, 2563, 2564, 2565, @@ -66475,54 +66429,53 @@ void zend_vm_init(void) 2569, 2570, 2571, - 2572, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, + 3481, }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -66695,7 +66648,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 = 2581 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2580 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -66703,7 +66656,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 = 2606 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2605 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -66711,7 +66664,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 = 2631 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2630 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -66722,17 +66675,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 = 2656 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2655 | 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 = 2681 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2680 | 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 = 2706 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2705 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -66743,17 +66696,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 = 2731 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2730 | 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 = 2756 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2755 | 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 = 2781 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2780 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -66764,14 +66717,14 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2806 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2805 | 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 = 2881 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2880 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3106 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3105 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -66782,14 +66735,14 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2956 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2955 | 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 = 3031 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3030 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3111 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3110 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -66800,12 +66753,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 = 2806 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2805 | 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 = 2881 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2880 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -66816,12 +66769,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 = 2956 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2955 | 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 = 3031 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3030 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -66829,12 +66782,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 = 3116 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3115 | 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 = 3191 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3190 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -66842,79 +66795,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 = 3266 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3265 | 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 = 3341 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3340 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3428 | SPEC_RULE_OP1; + spec = 3427 | SPEC_RULE_OP1; } else if (op1_info == MAY_BE_DOUBLE) { - spec = 3433 | SPEC_RULE_OP1; + spec = 3432 | 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 = 3438 | SPEC_RULE_OP1; + spec = 3437 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3416 | SPEC_RULE_RETVAL; + spec = 3415 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3418 | SPEC_RULE_RETVAL; + spec = 3417 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3420 | SPEC_RULE_RETVAL; + spec = 3419 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3422 | SPEC_RULE_RETVAL; + spec = 3421 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3424; + spec = 3423; } else if (op1_info == MAY_BE_LONG) { - spec = 3425; + spec = 3424; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3426; + spec = 3425; } else if (op1_info == MAY_BE_LONG) { - spec = 3427; + spec = 3426; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2580; + spec = 2579; } break; case ZEND_INIT_FCALL: if (Z_EXTRA_P(RT_CONSTANT(op, op->op2)) != 0) { - spec = 2573; + spec = 2572; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2574; + spec = 2573; } 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 = 3478; + spec = 3477; } 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 = 3473 | SPEC_RULE_OP1; + spec = 3472 | 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 = 3480 | SPEC_RULE_RETVAL; + spec = 3479 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -66922,22 +66875,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 = 3443 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3442 | 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 = 3479; + spec = 3478; } break; case ZEND_SEND_VAR: if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3468 | SPEC_RULE_OP1; + spec = 3467 | SPEC_RULE_OP1; } break; case ZEND_COUNT: if ((op1_info & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 2575 | SPEC_RULE_OP1; + spec = 2574 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index dd5a6ca03d0cb..0167ceddfc2a5 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -751,1119 +751,1118 @@ _(1586, ZEND_FE_RESET_R_SPEC_VAR) \ _(1588, ZEND_FE_RESET_R_SPEC_CV) \ _(1589, ZEND_FE_FETCH_R_SPEC_VAR) \ - _(1590, ZEND_EXIT_SPEC) \ - _(1591, ZEND_FETCH_R_SPEC_CONST_UNUSED) \ + _(1590, ZEND_FETCH_R_SPEC_CONST_UNUSED) \ + _(1591, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ _(1592, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ - _(1593, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ - _(1595, ZEND_FETCH_R_SPEC_CV_UNUSED) \ - _(1596, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \ + _(1594, ZEND_FETCH_R_SPEC_CV_UNUSED) \ + _(1595, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \ + _(1596, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ _(1597, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ - _(1598, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ - _(1600, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \ - _(1601, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ + _(1599, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \ + _(1600, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ + _(1601, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ _(1602, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1603, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1605, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ - _(1606, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ + _(1604, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ + _(1605, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ + _(1606, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ _(1607, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1608, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1610, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ - _(1616, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \ + _(1609, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ + _(1615, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \ + _(1616, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ _(1617, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ - _(1618, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ - _(1620, ZEND_FETCH_DIM_R_SPEC_CV_CV) \ - _(1621, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \ + _(1619, ZEND_FETCH_DIM_R_SPEC_CV_CV) \ + _(1620, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \ + _(1621, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ _(1622, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ - _(1623, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ - _(1625, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \ - _(1626, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ + _(1624, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \ + _(1625, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ + _(1626, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ _(1627, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1628, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1630, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ - _(1631, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ + _(1629, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ + _(1630, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ + _(1631, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ _(1632, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1633, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1635, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ - _(1636, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \ + _(1634, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ + _(1635, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \ + _(1636, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ _(1637, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ - _(1638, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ - _(1640, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \ - _(1641, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \ + _(1639, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \ + _(1640, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \ + _(1641, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ _(1642, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ - _(1643, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ - _(1645, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \ - _(1646, ZEND_FETCH_W_SPEC_CONST_UNUSED) \ + _(1644, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \ + _(1645, ZEND_FETCH_W_SPEC_CONST_UNUSED) \ + _(1646, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ _(1647, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ - _(1648, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ - _(1650, ZEND_FETCH_W_SPEC_CV_UNUSED) \ - _(1661, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \ + _(1649, ZEND_FETCH_W_SPEC_CV_UNUSED) \ + _(1660, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \ + _(1661, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ _(1662, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ - _(1663, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ - _(1664, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED) \ - _(1665, ZEND_FETCH_DIM_W_SPEC_VAR_CV) \ - _(1671, ZEND_FETCH_DIM_W_SPEC_CV_CONST) \ + _(1663, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED) \ + _(1664, ZEND_FETCH_DIM_W_SPEC_VAR_CV) \ + _(1670, ZEND_FETCH_DIM_W_SPEC_CV_CONST) \ + _(1671, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ _(1672, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ - _(1673, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ - _(1674, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED) \ - _(1675, ZEND_FETCH_DIM_W_SPEC_CV_CV) \ - _(1686, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST) \ + _(1673, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED) \ + _(1674, ZEND_FETCH_DIM_W_SPEC_CV_CV) \ + _(1685, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST) \ + _(1686, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ _(1687, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ - _(1688, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ - _(1690, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \ - _(1691, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \ + _(1689, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \ + _(1690, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \ + _(1691, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ _(1692, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ - _(1693, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ - _(1695, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \ - _(1696, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \ + _(1694, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \ + _(1695, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \ + _(1696, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ _(1697, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ - _(1698, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ - _(1700, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \ - _(1701, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \ + _(1699, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \ + _(1700, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \ + _(1701, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ _(1702, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ - _(1703, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ - _(1705, ZEND_FETCH_RW_SPEC_CV_UNUSED) \ - _(1716, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \ + _(1704, ZEND_FETCH_RW_SPEC_CV_UNUSED) \ + _(1715, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \ + _(1716, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ _(1717, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ - _(1718, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ - _(1719, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED) \ - _(1720, ZEND_FETCH_DIM_RW_SPEC_VAR_CV) \ - _(1726, ZEND_FETCH_DIM_RW_SPEC_CV_CONST) \ + _(1718, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED) \ + _(1719, ZEND_FETCH_DIM_RW_SPEC_VAR_CV) \ + _(1725, ZEND_FETCH_DIM_RW_SPEC_CV_CONST) \ + _(1726, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ _(1727, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ - _(1728, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ - _(1729, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED) \ - _(1730, ZEND_FETCH_DIM_RW_SPEC_CV_CV) \ - _(1741, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST) \ + _(1728, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED) \ + _(1729, ZEND_FETCH_DIM_RW_SPEC_CV_CV) \ + _(1740, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST) \ + _(1741, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ _(1742, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ - _(1743, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ - _(1745, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \ - _(1746, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \ + _(1744, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \ + _(1745, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \ + _(1746, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ _(1747, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ - _(1748, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ - _(1750, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \ - _(1751, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \ + _(1749, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \ + _(1750, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \ + _(1751, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ _(1752, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ - _(1753, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ - _(1755, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \ - _(1756, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \ + _(1754, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \ + _(1755, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \ + _(1756, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ _(1757, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ - _(1758, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ - _(1760, ZEND_FETCH_IS_SPEC_CV_UNUSED) \ - _(1761, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \ + _(1759, ZEND_FETCH_IS_SPEC_CV_UNUSED) \ + _(1760, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \ + _(1761, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ _(1762, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ - _(1763, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ - _(1765, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \ - _(1766, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ + _(1764, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \ + _(1765, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ + _(1766, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ _(1767, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1768, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1770, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ - _(1771, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ + _(1769, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ + _(1770, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ + _(1771, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ _(1772, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1773, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1775, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ - _(1781, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \ + _(1774, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ + _(1780, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \ + _(1781, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ _(1782, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ - _(1783, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ - _(1785, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \ - _(1786, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \ + _(1784, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \ + _(1785, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \ + _(1786, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ _(1787, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ - _(1788, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ - _(1790, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \ - _(1791, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ + _(1789, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \ + _(1790, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ + _(1791, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ _(1792, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1793, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1795, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ - _(1796, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ + _(1794, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ + _(1795, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ + _(1796, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ _(1797, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1798, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1800, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ - _(1801, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \ + _(1799, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ + _(1800, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \ + _(1801, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ _(1802, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ - _(1803, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ - _(1805, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \ - _(1806, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \ + _(1804, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \ + _(1805, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \ + _(1806, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ _(1807, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ - _(1808, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ - _(1810, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \ - _(1811, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \ + _(1809, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \ + _(1810, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \ + _(1811, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ _(1812, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ - _(1813, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ - _(1815, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED) \ - _(1816, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST) \ + _(1814, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED) \ + _(1815, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST) \ + _(1816, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ _(1817, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1818, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1819, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED) \ - _(1820, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV) \ - _(1821, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) \ + _(1818, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED) \ + _(1819, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV) \ + _(1820, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) \ + _(1821, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ _(1822, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1823, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1824, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) \ - _(1825, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) \ - _(1826, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST) \ + _(1823, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) \ + _(1824, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) \ + _(1825, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST) \ + _(1826, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ _(1827, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1828, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1829, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED) \ - _(1830, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV) \ - _(1836, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST) \ + _(1828, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED) \ + _(1829, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV) \ + _(1835, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST) \ + _(1836, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ _(1837, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1838, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1839, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED) \ - _(1840, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV) \ - _(1841, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST) \ + _(1838, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED) \ + _(1839, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV) \ + _(1840, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST) \ + _(1841, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ _(1842, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1843, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1845, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV) \ - _(1846, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) \ + _(1844, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV) \ + _(1845, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) \ + _(1846, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ _(1847, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1848, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1850, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) \ - _(1851, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST) \ + _(1849, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) \ + _(1850, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST) \ + _(1851, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ _(1852, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1853, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1855, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV) \ - _(1856, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1854, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV) \ + _(1855, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1856, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ _(1857, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ - _(1858, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ - _(1860, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV) \ - _(1861, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST) \ + _(1859, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV) \ + _(1860, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST) \ + _(1861, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ _(1862, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1863, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1865, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \ - _(1866, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \ + _(1864, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \ + _(1865, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \ + _(1866, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ _(1867, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ - _(1868, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ - _(1870, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \ - _(1881, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \ + _(1869, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \ + _(1880, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \ + _(1881, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ _(1882, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ - _(1883, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ - _(1885, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \ - _(1891, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \ + _(1884, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \ + _(1890, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \ + _(1891, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ _(1892, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ - _(1893, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ - _(1895, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \ - _(1906, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \ + _(1894, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \ + _(1905, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \ + _(1906, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ _(1907, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ - _(1908, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ - _(1910, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \ - _(1911, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \ + _(1909, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \ + _(1910, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \ + _(1911, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ _(1912, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ - _(1913, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ - _(1915, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \ - _(1916, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \ + _(1914, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \ + _(1915, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \ + _(1916, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ _(1917, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ - _(1918, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ - _(1920, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \ - _(1921, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \ + _(1919, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \ + _(1920, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \ + _(1921, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ _(1922, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ - _(1923, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ - _(1925, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \ - _(1926, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1924, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \ + _(1925, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1926, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ _(1927, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1928, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1930, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1931, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1929, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1930, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1931, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ _(1932, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1933, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1935, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1941, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1934, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1940, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1941, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ _(1942, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1943, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1945, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1946, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) \ + _(1944, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1945, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) \ + _(1946, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ _(1947, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ - _(1948, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ - _(1953, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED) \ - _(1954, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK) \ - _(1957, ZEND_EXT_STMT_SPEC) \ - _(1958, ZEND_EXT_FCALL_BEGIN_SPEC) \ - _(1959, ZEND_EXT_FCALL_END_SPEC) \ - _(1960, ZEND_EXT_NOP_SPEC) \ - _(1961, ZEND_TICKS_SPEC) \ - _(1962, ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST) \ - _(1965, ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED) \ - _(1967, ZEND_CATCH_SPEC_CONST) \ - _(1968, ZEND_THROW_SPEC_CONST) \ + _(1952, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED) \ + _(1953, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK) \ + _(1956, ZEND_EXT_STMT_SPEC) \ + _(1957, ZEND_EXT_FCALL_BEGIN_SPEC) \ + _(1958, ZEND_EXT_FCALL_END_SPEC) \ + _(1959, ZEND_EXT_NOP_SPEC) \ + _(1960, ZEND_TICKS_SPEC) \ + _(1961, ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST) \ + _(1964, ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED) \ + _(1966, ZEND_CATCH_SPEC_CONST) \ + _(1967, ZEND_THROW_SPEC_CONST) \ + _(1968, ZEND_THROW_SPEC_TMPVAR) \ _(1969, ZEND_THROW_SPEC_TMPVAR) \ - _(1970, ZEND_THROW_SPEC_TMPVAR) \ - _(1972, ZEND_THROW_SPEC_CV) \ - _(1973, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \ + _(1971, ZEND_THROW_SPEC_CV) \ + _(1972, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \ + _(1973, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ _(1974, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ - _(1975, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ - _(1976, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \ - _(1977, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \ - _(1978, ZEND_CLONE_SPEC_CONST) \ + _(1975, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \ + _(1976, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \ + _(1977, ZEND_CLONE_SPEC_CONST) \ + _(1978, ZEND_CLONE_SPEC_TMPVAR) \ _(1979, ZEND_CLONE_SPEC_TMPVAR) \ - _(1980, ZEND_CLONE_SPEC_TMPVAR) \ - _(1981, ZEND_CLONE_SPEC_UNUSED) \ - _(1982, ZEND_CLONE_SPEC_CV) \ - _(1983, ZEND_RETURN_BY_REF_SPEC_CONST) \ - _(1984, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ - _(1985, ZEND_RETURN_BY_REF_SPEC_TMP) \ - _(1986, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ - _(1987, ZEND_RETURN_BY_REF_SPEC_VAR) \ - _(1988, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ - _(1991, ZEND_RETURN_BY_REF_SPEC_CV) \ - _(1992, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ - _(1993, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) \ + _(1980, ZEND_CLONE_SPEC_UNUSED) \ + _(1981, ZEND_CLONE_SPEC_CV) \ + _(1982, ZEND_RETURN_BY_REF_SPEC_CONST) \ + _(1983, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ + _(1984, ZEND_RETURN_BY_REF_SPEC_TMP) \ + _(1985, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ + _(1986, ZEND_RETURN_BY_REF_SPEC_VAR) \ + _(1987, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ + _(1990, ZEND_RETURN_BY_REF_SPEC_CV) \ + _(1991, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ + _(1992, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) \ + _(1993, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ _(1994, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(1995, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(1997, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \ - _(1998, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ + _(1996, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \ + _(1997, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ + _(1998, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ _(1999, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(2000, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(2002, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ - _(2003, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ + _(2001, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ + _(2002, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ + _(2003, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ _(2004, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(2005, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(2007, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ - _(2008, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \ + _(2006, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ + _(2007, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \ + _(2008, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ _(2009, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2010, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2012, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \ - _(2013, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \ + _(2011, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \ + _(2012, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \ + _(2013, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ _(2014, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ - _(2015, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ - _(2017, ZEND_INIT_METHOD_CALL_SPEC_CV_CV) \ - _(2018, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) \ + _(2016, ZEND_INIT_METHOD_CALL_SPEC_CV_CV) \ + _(2017, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) \ + _(2018, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ _(2019, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(2020, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(2021, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) \ - _(2022, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) \ - _(2028, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) \ + _(2020, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) \ + _(2021, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) \ + _(2027, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) \ + _(2028, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ _(2029, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ - _(2030, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ - _(2031, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) \ - _(2032, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) \ - _(2033, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) \ + _(2030, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) \ + _(2031, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) \ + _(2032, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) \ + _(2033, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ _(2034, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2035, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2036, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) \ - _(2037, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) \ - _(2043, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) \ + _(2035, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) \ + _(2036, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) \ + _(2042, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) \ + _(2043, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ _(2044, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ - _(2045, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ - _(2047, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED) \ - _(2048, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST) \ + _(2046, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED) \ + _(2047, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST) \ + _(2048, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ _(2049, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ - _(2050, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ - _(2052, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \ - _(2053, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ + _(2051, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \ + _(2052, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ + _(2053, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ _(2054, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2055, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2057, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ - _(2058, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ + _(2056, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ + _(2057, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ + _(2058, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ _(2059, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2060, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2062, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ - _(2068, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \ + _(2061, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ + _(2067, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \ + _(2068, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ _(2069, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ - _(2070, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ - _(2072, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV) \ + _(2071, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV) \ + _(2072, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ _(2073, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ - _(2074, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ - _(2079, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED) \ - _(2080, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK) \ + _(2078, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED) \ + _(2079, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK) \ + _(2082, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ _(2083, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ - _(2084, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ - _(2089, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED) \ - _(2090, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK) \ - _(2133, ZEND_SEND_VAR_SPEC_VAR_CONST) \ - _(2136, ZEND_SEND_VAR_SPEC_VAR_UNUSED) \ - _(2143, ZEND_SEND_VAR_SPEC_CV_CONST) \ - _(2146, ZEND_SEND_VAR_SPEC_CV_UNUSED) \ - _(2148, ZEND_INIT_USER_CALL_SPEC_CONST_CONST) \ + _(2088, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED) \ + _(2089, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK) \ + _(2132, ZEND_SEND_VAR_SPEC_VAR_CONST) \ + _(2135, ZEND_SEND_VAR_SPEC_VAR_UNUSED) \ + _(2142, ZEND_SEND_VAR_SPEC_CV_CONST) \ + _(2145, ZEND_SEND_VAR_SPEC_CV_UNUSED) \ + _(2147, ZEND_INIT_USER_CALL_SPEC_CONST_CONST) \ + _(2148, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ _(2149, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ - _(2150, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ - _(2152, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \ - _(2153, ZEND_SEND_ARRAY_SPEC) \ - _(2154, ZEND_SEND_USER_SPEC_CONST) \ - _(2155, ZEND_SEND_USER_SPEC_TMP) \ - _(2156, ZEND_SEND_USER_SPEC_VAR) \ - _(2158, ZEND_SEND_USER_SPEC_CV) \ - _(2159, ZEND_STRLEN_SPEC_CONST) \ + _(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) \ + _(2155, ZEND_SEND_USER_SPEC_VAR) \ + _(2157, ZEND_SEND_USER_SPEC_CV) \ + _(2158, ZEND_STRLEN_SPEC_CONST) \ + _(2159, ZEND_STRLEN_SPEC_TMPVAR) \ _(2160, ZEND_STRLEN_SPEC_TMPVAR) \ - _(2161, ZEND_STRLEN_SPEC_TMPVAR) \ - _(2163, ZEND_STRLEN_SPEC_CV) \ - _(2164, ZEND_DEFINED_SPEC_CONST) \ - _(2165, ZEND_TYPE_CHECK_SPEC_CONST) \ + _(2162, ZEND_STRLEN_SPEC_CV) \ + _(2163, ZEND_DEFINED_SPEC_CONST) \ + _(2164, ZEND_TYPE_CHECK_SPEC_CONST) \ + _(2165, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ _(2166, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ - _(2167, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ - _(2169, ZEND_TYPE_CHECK_SPEC_CV) \ - _(2170, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \ - _(2171, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \ - _(2172, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \ - _(2173, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \ - _(2174, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \ - _(2175, ZEND_FE_RESET_RW_SPEC_CONST) \ - _(2176, ZEND_FE_RESET_RW_SPEC_TMP) \ - _(2177, ZEND_FE_RESET_RW_SPEC_VAR) \ - _(2179, ZEND_FE_RESET_RW_SPEC_CV) \ - _(2180, ZEND_FE_FETCH_RW_SPEC_VAR) \ - _(2181, ZEND_FE_FREE_SPEC_TMPVAR) \ - _(2182, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \ + _(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_TMPVAR) \ _(2183, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ - _(2184, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ - _(2186, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \ - _(2187, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \ - _(2188, ZEND_DO_ICALL_SPEC_RETVAL_USED) \ + _(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_ICALL_SPEC_OBSERVER) \ - _(2191, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \ - _(2192, ZEND_DO_UCALL_SPEC_RETVAL_USED) \ + _(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_UCALL_SPEC_OBSERVER) \ - _(2195, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \ - _(2196, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \ + _(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) \ - _(2198, ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER) \ - _(2209, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \ + _(2208, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \ + _(2209, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ _(2210, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2211, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2213, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \ - _(2214, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2212, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \ + _(2213, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2214, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ _(2215, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2216, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2218, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \ - _(2219, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \ + _(2217, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \ + _(2218, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \ + _(2219, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ _(2220, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2221, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2223, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \ - _(2234, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \ + _(2222, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \ + _(2233, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \ + _(2234, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ _(2235, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2236, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2238, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \ - _(2239, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2237, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \ + _(2238, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2239, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ _(2240, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2241, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2243, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \ - _(2244, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \ + _(2242, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \ + _(2243, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \ + _(2244, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ _(2245, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2246, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2248, ZEND_POST_INC_OBJ_SPEC_CV_CV) \ - _(2249, ZEND_ECHO_SPEC_CONST) \ + _(2247, ZEND_POST_INC_OBJ_SPEC_CV_CV) \ + _(2248, ZEND_ECHO_SPEC_CONST) \ + _(2249, ZEND_ECHO_SPEC_TMPVAR) \ _(2250, ZEND_ECHO_SPEC_TMPVAR) \ - _(2251, ZEND_ECHO_SPEC_TMPVAR) \ - _(2253, ZEND_ECHO_SPEC_CV) \ - _(2260, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ - _(2262, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ - _(2263, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ - _(2265, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ - _(2267, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ - _(2268, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ - _(2275, ZEND_INSTANCEOF_SPEC_CV_CONST) \ - _(2277, ZEND_INSTANCEOF_SPEC_CV_VAR) \ - _(2278, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \ - _(2280, ZEND_GENERATOR_CREATE_SPEC) \ - _(2283, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \ - _(2285, ZEND_MAKE_REF_SPEC_CV_UNUSED) \ - _(2286, ZEND_DECLARE_FUNCTION_SPEC) \ - _(2287, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST) \ - _(2288, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ - _(2289, ZEND_DECLARE_CLASS_SPEC_CONST) \ - _(2290, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \ - _(2291, ZEND_DECLARE_ANON_CLASS_SPEC) \ - _(2292, ZEND_ADD_ARRAY_UNPACK_SPEC) \ - _(2293, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ + _(2252, ZEND_ECHO_SPEC_CV) \ + _(2259, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ + _(2261, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ + _(2262, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ + _(2264, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ + _(2266, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ + _(2267, ZEND_INSTANCEOF_SPEC_TMPVAR_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_CONST) \ + _(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_TMPVAR) \ _(2294, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ - _(2295, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ - _(2297, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ - _(2298, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ + _(2296, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ + _(2297, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ + _(2298, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ _(2299, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2300, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2302, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ - _(2303, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ + _(2301, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ + _(2302, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ + _(2303, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ _(2304, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2305, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2307, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ - _(2308, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ + _(2306, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ + _(2307, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ + _(2308, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ _(2309, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2310, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2312, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ - _(2313, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ + _(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_TMPVAR) \ _(2314, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ - _(2315, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ - _(2317, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ - _(2318, ZEND_HANDLE_EXCEPTION_SPEC) \ - _(2319, ZEND_USER_OPCODE_SPEC) \ - _(2320, ZEND_ASSERT_CHECK_SPEC) \ - _(2321, ZEND_JMP_SET_SPEC_CONST) \ - _(2322, ZEND_JMP_SET_SPEC_TMP) \ - _(2323, ZEND_JMP_SET_SPEC_VAR) \ - _(2325, ZEND_JMP_SET_SPEC_CV) \ - _(2326, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ - _(2327, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ - _(2328, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ - _(2329, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ + _(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) \ + _(2322, ZEND_JMP_SET_SPEC_VAR) \ + _(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_TMPVAR) \ _(2330, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ - _(2331, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ - _(2333, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ - _(2334, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ + _(2332, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ + _(2333, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ + _(2335, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ _(2336, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ - _(2337, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ - _(2338, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ - _(2339, ZEND_FETCH_CLASS_NAME_SPEC_CV) \ - _(2340, ZEND_CALL_TRAMPOLINE_SPEC) \ - _(2341, ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER) \ - _(2342, ZEND_DISCARD_EXCEPTION_SPEC) \ - _(2343, ZEND_YIELD_SPEC_CONST_CONST) \ + _(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_TMPVAR) \ _(2344, ZEND_YIELD_SPEC_CONST_TMPVAR) \ - _(2345, ZEND_YIELD_SPEC_CONST_TMPVAR) \ - _(2346, ZEND_YIELD_SPEC_CONST_UNUSED) \ - _(2347, ZEND_YIELD_SPEC_CONST_CV) \ - _(2348, ZEND_YIELD_SPEC_TMP_CONST) \ + _(2345, ZEND_YIELD_SPEC_CONST_UNUSED) \ + _(2346, ZEND_YIELD_SPEC_CONST_CV) \ + _(2347, ZEND_YIELD_SPEC_TMP_CONST) \ + _(2348, ZEND_YIELD_SPEC_TMP_TMPVAR) \ _(2349, ZEND_YIELD_SPEC_TMP_TMPVAR) \ - _(2350, ZEND_YIELD_SPEC_TMP_TMPVAR) \ - _(2351, ZEND_YIELD_SPEC_TMP_UNUSED) \ - _(2352, ZEND_YIELD_SPEC_TMP_CV) \ - _(2353, ZEND_YIELD_SPEC_VAR_CONST) \ + _(2350, ZEND_YIELD_SPEC_TMP_UNUSED) \ + _(2351, ZEND_YIELD_SPEC_TMP_CV) \ + _(2352, ZEND_YIELD_SPEC_VAR_CONST) \ + _(2353, ZEND_YIELD_SPEC_VAR_TMPVAR) \ _(2354, ZEND_YIELD_SPEC_VAR_TMPVAR) \ - _(2355, ZEND_YIELD_SPEC_VAR_TMPVAR) \ - _(2356, ZEND_YIELD_SPEC_VAR_UNUSED) \ - _(2357, ZEND_YIELD_SPEC_VAR_CV) \ - _(2358, ZEND_YIELD_SPEC_UNUSED_CONST) \ + _(2355, ZEND_YIELD_SPEC_VAR_UNUSED) \ + _(2356, ZEND_YIELD_SPEC_VAR_CV) \ + _(2357, ZEND_YIELD_SPEC_UNUSED_CONST) \ + _(2358, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ _(2359, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ - _(2360, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ - _(2361, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ - _(2362, ZEND_YIELD_SPEC_UNUSED_CV) \ - _(2363, ZEND_YIELD_SPEC_CV_CONST) \ + _(2360, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ + _(2361, ZEND_YIELD_SPEC_UNUSED_CV) \ + _(2362, ZEND_YIELD_SPEC_CV_CONST) \ + _(2363, ZEND_YIELD_SPEC_CV_TMPVAR) \ _(2364, ZEND_YIELD_SPEC_CV_TMPVAR) \ - _(2365, ZEND_YIELD_SPEC_CV_TMPVAR) \ - _(2366, ZEND_YIELD_SPEC_CV_UNUSED) \ - _(2367, ZEND_YIELD_SPEC_CV_CV) \ - _(2368, ZEND_GENERATOR_RETURN_SPEC_CONST) \ - _(2369, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ - _(2370, ZEND_GENERATOR_RETURN_SPEC_TMP) \ - _(2371, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ - _(2372, ZEND_GENERATOR_RETURN_SPEC_VAR) \ - _(2373, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ - _(2376, ZEND_GENERATOR_RETURN_SPEC_CV) \ - _(2377, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ - _(2378, ZEND_FAST_CALL_SPEC) \ - _(2379, ZEND_FAST_RET_SPEC) \ - _(2380, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ - _(2381, ZEND_SEND_UNPACK_SPEC) \ - _(2382, ZEND_YIELD_FROM_SPEC_CONST) \ + _(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_TMPVAR) \ _(2383, ZEND_YIELD_FROM_SPEC_TMPVAR) \ - _(2384, ZEND_YIELD_FROM_SPEC_TMPVAR) \ - _(2386, ZEND_YIELD_FROM_SPEC_CV) \ - _(2387, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ - _(2388, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ - _(2389, ZEND_COALESCE_SPEC_CONST) \ - _(2390, ZEND_COALESCE_SPEC_TMP) \ - _(2391, ZEND_COALESCE_SPEC_VAR) \ - _(2393, ZEND_COALESCE_SPEC_CV) \ - _(2394, ZEND_SPACESHIP_SPEC_CONST_CONST) \ + _(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) \ + _(2390, ZEND_COALESCE_SPEC_VAR) \ + _(2392, ZEND_COALESCE_SPEC_CV) \ + _(2393, ZEND_SPACESHIP_SPEC_CONST_CONST) \ + _(2394, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ _(2395, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ - _(2396, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ - _(2398, ZEND_SPACESHIP_SPEC_CONST_CV) \ - _(2399, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(2397, ZEND_SPACESHIP_SPEC_CONST_CV) \ + _(2398, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(2399, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ _(2400, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2401, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2403, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(2404, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(2402, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(2403, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(2404, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ _(2405, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2406, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2408, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(2414, ZEND_SPACESHIP_SPEC_CV_CONST) \ + _(2407, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(2413, ZEND_SPACESHIP_SPEC_CV_CONST) \ + _(2414, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ _(2415, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ - _(2416, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ - _(2418, ZEND_SPACESHIP_SPEC_CV_CV) \ - _(2419, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ - _(2420, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ - _(2423, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ - _(2425, ZEND_FETCH_STATIC_PROP_R_SPEC) \ - _(2426, ZEND_FETCH_STATIC_PROP_W_SPEC) \ - _(2427, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ - _(2428, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ - _(2429, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ - _(2430, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ - _(2431, ZEND_UNSET_STATIC_PROP_SPEC) \ - _(2432, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ - _(2433, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ + _(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) \ - _(2435, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ - _(2437, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ - _(2443, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ + _(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) \ - _(2445, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ - _(2447, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ - _(2448, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ + _(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) \ - _(2450, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ - _(2452, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ - _(2458, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ - _(2459, ZEND_BIND_STATIC_SPEC_CV) \ - _(2460, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ - _(2461, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \ - _(2464, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \ - _(2466, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ - _(2467, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ + _(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) \ - _(2469, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2471, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2472, ZEND_SWITCH_STRING_SPEC_CONST_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) \ - _(2474, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2476, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2477, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ - _(2478, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ - _(2479, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ - _(2481, ZEND_IN_ARRAY_SPEC_CV_CONST) \ - _(2482, ZEND_COUNT_SPEC_CONST_UNUSED) \ + _(2475, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2476, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ + _(2477, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ + _(2478, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ + _(2480, ZEND_IN_ARRAY_SPEC_CV_CONST) \ + _(2481, ZEND_COUNT_SPEC_CONST_UNUSED) \ + _(2482, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ _(2483, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ - _(2484, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ - _(2486, ZEND_COUNT_SPEC_CV_UNUSED) \ - _(2487, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ + _(2485, ZEND_COUNT_SPEC_CV_UNUSED) \ + _(2486, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ + _(2487, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ _(2488, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ - _(2489, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ - _(2490, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ - _(2491, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ - _(2492, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ - _(2493, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ - _(2494, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ - _(2495, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ - _(2497, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ - _(2498, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ + _(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) \ + _(2494, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ + _(2496, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ + _(2497, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ + _(2498, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ _(2499, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ - _(2500, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ - _(2502, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ - _(2503, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ + _(2501, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ + _(2502, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ + _(2503, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ _(2504, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2505, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2507, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(2508, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ + _(2506, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(2507, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ + _(2508, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ _(2509, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2510, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2512, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(2518, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ + _(2511, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(2517, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ + _(2518, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ _(2519, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ - _(2520, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ - _(2522, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ - _(2523, ZEND_MATCH_SPEC_CONST_CONST) \ + _(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) \ - _(2525, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2527, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2533, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ - _(2534, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ - _(2535, ZEND_CASE_STRICT_SPEC_TMP_VAR) \ - _(2537, ZEND_CASE_STRICT_SPEC_TMP_CV) \ - _(2538, ZEND_CASE_STRICT_SPEC_VAR_CONST) \ - _(2539, ZEND_CASE_STRICT_SPEC_VAR_TMP) \ - _(2540, ZEND_CASE_STRICT_SPEC_VAR_VAR) \ - _(2542, ZEND_CASE_STRICT_SPEC_VAR_CV) \ - _(2553, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ + _(2526, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2532, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ + _(2533, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ + _(2534, ZEND_CASE_STRICT_SPEC_TMP_VAR) \ + _(2536, ZEND_CASE_STRICT_SPEC_TMP_CV) \ + _(2537, ZEND_CASE_STRICT_SPEC_VAR_CONST) \ + _(2538, ZEND_CASE_STRICT_SPEC_VAR_TMP) \ + _(2539, ZEND_CASE_STRICT_SPEC_VAR_VAR) \ + _(2541, ZEND_CASE_STRICT_SPEC_VAR_CV) \ + _(2552, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ + _(2553, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ _(2554, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2555, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2557, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2558, ZEND_JMP_NULL_SPEC_CONST) \ - _(2559, ZEND_JMP_NULL_SPEC_TMP) \ - _(2560, ZEND_JMP_NULL_SPEC_VAR) \ - _(2562, ZEND_JMP_NULL_SPEC_CV) \ - _(2563, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ - _(2564, ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED) \ - _(2565, ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED) \ - _(2566, ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED) \ - _(2567, ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV) \ - _(2568, ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED) \ - _(2569, ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED) \ - _(2570, ZEND_FRAMELESS_ICALL_2_SPEC) \ - _(2571, ZEND_FRAMELESS_ICALL_3_SPEC) \ - _(2572, ZEND_JMP_FRAMELESS_SPEC_CONST) \ - _(2573, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \ - _(2574, ZEND_RECV_NOTYPE_SPEC) \ + _(2556, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2557, ZEND_JMP_NULL_SPEC_CONST) \ + _(2558, ZEND_JMP_NULL_SPEC_TMP) \ + _(2559, ZEND_JMP_NULL_SPEC_VAR) \ + _(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_1_SPEC_UNUSED) \ + _(2569, ZEND_FRAMELESS_ICALL_2_SPEC) \ + _(2570, ZEND_FRAMELESS_ICALL_3_SPEC) \ + _(2571, ZEND_JMP_FRAMELESS_SPEC_CONST) \ + _(2572, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \ + _(2573, ZEND_RECV_NOTYPE_SPEC) \ + _(2575, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \ _(2576, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \ - _(2577, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \ - _(2579, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \ - _(2580, ZEND_JMP_FORWARD_SPEC) \ - _(2586, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2578, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \ + _(2579, ZEND_JMP_FORWARD_SPEC) \ + _(2585, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2586, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2587, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2588, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2590, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2591, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2589, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2590, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2591, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2592, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2593, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2595, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2601, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2594, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2600, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2601, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2602, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2603, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2605, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2611, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2604, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2610, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2611, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2612, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2613, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2615, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2616, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2614, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2615, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2616, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2617, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2618, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2620, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2626, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2619, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2625, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2626, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2627, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2628, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2630, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2636, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2629, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2635, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2636, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2637, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2638, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2640, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2641, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2639, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2640, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2641, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2642, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2643, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2645, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2651, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2644, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2650, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2651, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2652, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2653, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2655, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2654, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2656, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ _(2657, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2658, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2660, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2661, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2659, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2660, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2661, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2662, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2663, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2665, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2666, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2664, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2665, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2666, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2667, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2668, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2670, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2676, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2669, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2675, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2676, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2677, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2678, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2680, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2679, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2681, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ _(2682, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2683, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2685, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2686, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2684, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2685, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2686, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2687, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2688, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2690, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2691, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2689, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2690, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2691, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2692, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2693, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2695, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2701, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2694, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2700, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2701, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2702, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2703, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2705, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2704, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2706, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ _(2707, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2708, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2710, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2711, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2709, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2710, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2711, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2712, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2713, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2715, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2716, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2714, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2715, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2716, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2717, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2718, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2720, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2726, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2719, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2725, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2726, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2727, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2728, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2730, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2736, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2729, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2735, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2736, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2737, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2738, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2740, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2741, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2739, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2740, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2741, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2742, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2743, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2745, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2751, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2744, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2750, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2751, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2752, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2753, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2755, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2761, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2754, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2760, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2761, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2762, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2763, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2765, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2766, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2764, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2765, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2766, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2767, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2768, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2770, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2776, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2769, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2775, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2776, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2777, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2778, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2780, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2786, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2779, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2785, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2786, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2787, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2788, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2790, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2791, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2789, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2790, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2791, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2792, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2793, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2795, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2801, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2794, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2800, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2801, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2802, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2803, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2805, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2821, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2822, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2823, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2824, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2825, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2826, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2827, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2828, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2829, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2849, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2850, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2866, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2867, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2868, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2869, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2870, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2871, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2872, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2873, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2874, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2878, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2879, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2880, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2896, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2897, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2898, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2899, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2900, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2901, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2902, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2903, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2904, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2924, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2925, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2941, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2942, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2943, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2944, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2945, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2946, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2947, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2948, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2949, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2953, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2954, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2955, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2971, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2972, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2973, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2974, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2975, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2976, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2977, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2978, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2979, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2999, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3000, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3016, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3017, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3018, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3019, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3020, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3021, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3022, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3023, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3024, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3028, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3029, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3030, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3046, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3047, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3048, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3049, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3050, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3051, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3052, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3053, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3054, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3074, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3075, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3091, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3092, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3093, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3094, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3095, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3096, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3097, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3098, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3099, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3103, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3104, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3105, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3106, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3110, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3111, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3115, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3119, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3120, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3121, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3122, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3123, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3124, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3128, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3129, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3130, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3131, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3132, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3133, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3134, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3135, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3136, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3137, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3138, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3139, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3152, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3153, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3154, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3158, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3159, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3160, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3176, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3177, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3178, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3179, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3180, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3181, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3182, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3183, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3184, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3188, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3189, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3190, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3194, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3195, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3196, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3197, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3198, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3199, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3203, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3204, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3205, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3206, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3207, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3208, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3209, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3210, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3211, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3212, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3213, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3214, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3233, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3234, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3235, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3251, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3252, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3253, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3254, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3255, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3256, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3257, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3258, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3259, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3263, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3264, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3265, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3269, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3270, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3271, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3272, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3273, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3278, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3279, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3280, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3281, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3282, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3283, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3284, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3285, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3286, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3287, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3288, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3289, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3308, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3309, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3310, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3326, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3327, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3328, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3329, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3330, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3331, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3332, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3333, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3334, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3338, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3339, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3340, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3344, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3345, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3346, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3347, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3348, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3353, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3354, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3355, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3356, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3357, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3358, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3359, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3360, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3361, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3362, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3363, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3364, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3383, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3384, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3385, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3401, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3402, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3403, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3404, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3405, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3406, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3407, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3408, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3409, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3413, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3414, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3415, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3416, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3417, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3418, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3419, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3420, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3421, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3422, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3423, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3424, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3425, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3426, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3427, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3428, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(2804, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2820, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2821, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2822, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_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) \ + _(2826, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2827, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2828, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2832, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_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) \ + _(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2849, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2865, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2866, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2867, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_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) \ + _(2871, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2872, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2873, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2877, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2878, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2879, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2895, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2896, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2897, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_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) \ + _(2901, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2902, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2903, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2907, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_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) \ + _(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2924, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2940, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2941, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2942, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_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) \ + _(2946, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2947, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2948, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2952, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2953, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2954, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2970, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2971, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2972, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_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) \ + _(2976, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2977, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2978, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2982, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_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) \ + _(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2999, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3015, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3016, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3017, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_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) \ + _(3021, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3022, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3023, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3027, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3028, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3029, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3045, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3046, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3047, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_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) \ + _(3051, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3052, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3053, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3057, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_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) \ + _(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3074, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3090, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3091, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3092, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_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) \ + _(3096, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3097, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3098, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3102, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3103, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3104, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3105, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3109, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3110, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3114, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3118, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3119, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3120, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(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) \ + _(3127, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3128, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3129, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3130, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3131, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3132, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3133, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3134, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3135, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_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) \ + _(3142, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_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) \ + _(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3158, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3159, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3175, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3176, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3177, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3178, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3179, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3180, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_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) \ + _(3187, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3188, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3189, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3193, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3194, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3195, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_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) \ + _(3202, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3203, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3204, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3205, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3206, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3207, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3208, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3209, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3210, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_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) \ + _(3217, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_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) \ + _(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3233, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3234, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3250, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3251, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3252, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3253, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3254, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3255, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_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) \ + _(3262, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3263, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3264, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3268, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3269, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3270, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_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) \ + _(3277, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3278, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3279, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3280, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3281, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3282, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3283, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3284, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3285, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_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) \ + _(3292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_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) \ + _(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3308, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3309, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3325, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3326, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3327, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3328, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3329, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3330, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_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) \ + _(3337, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3338, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3339, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3343, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3344, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3345, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_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) \ + _(3352, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3353, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3354, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3355, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3356, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3357, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3358, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3359, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3360, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_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) \ + _(3367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_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) \ + _(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3383, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3384, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3400, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3401, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3402, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3403, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3404, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3405, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_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) \ + _(3412, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3413, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3414, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3415, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3416, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3417, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3418, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3419, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3420, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3421, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3422, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3423, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3424, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3425, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3426, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3427, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3428, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ _(3429, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3430, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3432, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3433, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3431, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3432, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3433, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ _(3434, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3435, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3437, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3438, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3436, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3437, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3438, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ _(3439, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3440, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3442, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3441, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3443, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ _(3444, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3445, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3447, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3448, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3446, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3447, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3448, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ _(3449, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3450, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3452, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3453, 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_CONST) \ + _(3453, 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_TMPVARCV) \ - _(3457, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3463, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3456, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3462, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3463, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ _(3464, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3465, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3467, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3470, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3472, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3475, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ - _(3477, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ - _(3478, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3479, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3480, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3481, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3481+1, ZEND_NULL) + _(3466, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3469, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3471, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3474, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ + _(3476, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ + _(3477, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3478, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3479, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3480, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3480+1, ZEND_NULL) diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index 218a55a8f4e8b..9bc195f2eb953 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -102,7 +102,7 @@ static const char *zend_vm_opcodes_names[209] = { "ZEND_UNSET_OBJ", "ZEND_FE_RESET_R", "ZEND_FE_FETCH_R", - "ZEND_EXIT", + NULL, "ZEND_FETCH_R", "ZEND_FETCH_DIM_R", "ZEND_FETCH_OBJ_R", diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h index a273a9b7e2de0..f4a7f73829289 100644 --- a/Zend/zend_vm_opcodes.h +++ b/Zend/zend_vm_opcodes.h @@ -161,7 +161,6 @@ END_EXTERN_C() #define ZEND_UNSET_OBJ 76 #define ZEND_FE_RESET_R 77 #define ZEND_FE_FETCH_R 78 -#define ZEND_EXIT 79 #define ZEND_FETCH_R 80 #define ZEND_FETCH_DIM_R 81 #define ZEND_FETCH_OBJ_R 82 diff --git a/ext/ftp/tests/server.inc b/ext/ftp/tests/server.inc index 04a87f6f867db..745efd263295e 100644 --- a/ext/ftp/tests/server.inc +++ b/ext/ftp/tests/server.inc @@ -19,7 +19,7 @@ if ($pid) { function dump_and_exit($buf) { var_dump($buf); - exit; + exit(); } function anonymous() @@ -75,7 +75,7 @@ if ($pid) { fputs($s, "666 dummy\r\n"); sleep(1); fputs($s, "666 bogus msg\r\n"); - exit; + exit(); } if (!stream_socket_enable_crypto($s, true, STREAM_CRYPTO_METHOD_SSLv23_SERVER)) { @@ -110,7 +110,7 @@ if ($pid) { $user = $m[1]; if ($user !== 'user' && $user !== 'anonymous') { fputs($s, "530 Not logged in.\r\n"); - exit; + exit(); } if (anonymous()) { @@ -129,7 +129,7 @@ if ($pid) { fputs($s, "230 User logged in\r\n"); } else { fputs($s, "530 Not logged in.\r\n"); - exit; + exit(); } } } @@ -470,7 +470,7 @@ if ($pid) { fputs($fs, "file1\r\nfile1\r\nfile\nb0rk\r\n"); fputs($s, "226 Closing data Connection.\r\n"); fclose($fs); - + fputs($s, "226 Transfer complete\r\n"); }elseif (preg_match('/^LIST no_exists\//', $buf, $matches)) { fputs($s, "425 Error establishing connection\r\n"); @@ -536,7 +536,7 @@ if ($pid) { dump_and_exit($buf); } } - exit; + exit(); } fclose($socket); diff --git a/ext/opcache/jit/zend_jit.c b/ext/opcache/jit/zend_jit.c index caf9e8d086c6e..6e0f165baf0fe 100644 --- a/ext/opcache/jit/zend_jit.c +++ b/ext/opcache/jit/zend_jit.c @@ -2513,7 +2513,6 @@ static int zend_jit(const zend_op_array *op_array, zend_ssa *ssa, const zend_op case ZEND_GENERATOR_RETURN: case ZEND_RETURN_BY_REF: case ZEND_RETURN: - case ZEND_EXIT: case ZEND_MATCH_ERROR: /* switch through trampoline */ case ZEND_YIELD: @@ -3424,7 +3423,6 @@ ZEND_EXT_API int zend_jit_check_support(void) /* JIT has no effect on these opcodes */ case ZEND_BEGIN_SILENCE: case ZEND_END_SILENCE: - case ZEND_EXIT: break; default: if (zend_get_user_opcode_handler(i) != NULL) { diff --git a/ext/opcache/jit/zend_jit_ir.c b/ext/opcache/jit/zend_jit_ir.c index 200f40284d2dc..a8e5e967dfa19 100644 --- a/ext/opcache/jit/zend_jit_ir.c +++ b/ext/opcache/jit/zend_jit_ir.c @@ -5398,7 +5398,7 @@ static int zend_jit_add_arrays(zend_jit_ctx *jit, const zend_op *opline, uint32_ static int zend_jit_long_math_helper(zend_jit_ctx *jit, const zend_op *opline, uint8_t opcode, - uint8_t op1_type, + uint8_t op1_type, znode_op op1, zend_jit_addr op1_addr, uint32_t op1_info, @@ -7908,7 +7908,7 @@ static int zend_jit_type_check(zend_jit_ctx *jit, const zend_op *opline, uint32_ if (op1_info & (MAY_BE_ANY|MAY_BE_REF)) { mask = opline->extended_value; - if (!(op1_info & MAY_BE_GUARD) && !(op1_info & (MAY_BE_ANY - mask))) { + if (!(op1_info & MAY_BE_GUARD) && !(op1_info & (MAY_BE_ANY - mask))) { jit_FREE_OP(jit, opline->op1_type, opline->op1, op1_info, opline); if (exit_addr) { if (smart_branch_opcode == ZEND_JMPNZ) { @@ -11780,7 +11780,7 @@ static int zend_jit_fetch_dimension_address_inner(zend_jit_ctx *jit, if (opline->op2_type != IS_CONST) { ir_ref if_num, end1, ref2; - if_num = ir_IF( + if_num = ir_IF( ir_ULE( ir_LOAD_C(ir_ADD_OFFSET(key, offsetof(zend_string, val))), ir_CONST_CHAR('9'))); @@ -16157,8 +16157,7 @@ static int zend_jit_trace_handler(zend_jit_ctx *jit, const zend_op_array *op_arr } else { ir_GUARD(ir_GE(ref, ir_CONST_I32(0)), jit_STUB_ADDR(jit, jit_stub_trace_halt)); } - } else if (opline->opcode == ZEND_EXIT || - opline->opcode == ZEND_GENERATOR_RETURN || + } else if (opline->opcode == ZEND_GENERATOR_RETURN || opline->opcode == ZEND_YIELD || opline->opcode == ZEND_YIELD_FROM) { ir_IJMP(jit_STUB_ADDR(jit, jit_stub_trace_halt)); diff --git a/ext/opcache/jit/zend_jit_trace.c b/ext/opcache/jit/zend_jit_trace.c index db8fa7356c998..ad2e202763201 100644 --- a/ext/opcache/jit/zend_jit_trace.c +++ b/ext/opcache/jit/zend_jit_trace.c @@ -314,7 +314,6 @@ static int zend_jit_trace_may_exit(const zend_op_array *op_array, const zend_op case ZEND_FAST_RET: case ZEND_GENERATOR_CREATE: case ZEND_GENERATOR_RETURN: - case ZEND_EXIT: case ZEND_YIELD: case ZEND_YIELD_FROM: case ZEND_INCLUDE_OR_EVAL: diff --git a/ext/opcache/tests/jit/ignored_opcodes.phpt b/ext/opcache/tests/jit/ignored_opcodes.phpt index 761a0b699a73a..eac4c237a9c09 100644 --- a/ext/opcache/tests/jit/ignored_opcodes.phpt +++ b/ext/opcache/tests/jit/ignored_opcodes.phpt @@ -9,7 +9,7 @@ opcache.jit=function zend_test.observer.enabled=1 zend_test.observer.show_output=1 zend_test.observer.observe_all=1 -zend_test.observer.show_opcode_in_user_handler=ZEND_EXIT, ZEND_BEGIN_SILENCE, ZEND_END_SILENCE +zend_test.observer.show_opcode_in_user_handler=ZEND_BEGIN_SILENCE, ZEND_END_SILENCE --EXTENSIONS-- opcache zend_test @@ -27,6 +27,9 @@ exit(@test()); - + + + + diff --git a/ext/standard/tests/array/array_filter_variation9.phpt b/ext/standard/tests/array/array_filter_variation9.phpt index d9c1f9258f3a9..ff0dc7711718b 100644 --- a/ext/standard/tests/array/array_filter_variation9.phpt +++ b/ext/standard/tests/array/array_filter_variation9.phpt @@ -23,9 +23,9 @@ try { echo $e->getMessage(), "\n"; } -// using language construct 'exit' as 'callback' +// using language construct 'isset' as 'callback' try { - var_dump( array_filter($input, 'exit') ); + var_dump( array_filter($input, 'isset') ); } catch (TypeError $e) { echo $e->getMessage(), "\n"; } @@ -63,5 +63,5 @@ array(6) { int(1000) } array_filter(): Argument #2 ($callback) must be a valid callback or null, function "echo" not found or invalid function name -array_filter(): Argument #2 ($callback) must be a valid callback or null, function "exit" not found or invalid function name +array_filter(): Argument #2 ($callback) must be a valid callback or null, function "isset" not found or invalid function name Done diff --git a/ext/standard/tests/array/array_map_variation16.phpt b/ext/standard/tests/array/array_map_variation16.phpt index b7c6690040162..7f835022febcf 100644 --- a/ext/standard/tests/array/array_map_variation16.phpt +++ b/ext/standard/tests/array/array_map_variation16.phpt @@ -2,32 +2,24 @@ Test array_map() function : usage variations - failing built-in functions & language constructs --FILE-- getMessage(), "\n"; } @@ -36,21 +28,11 @@ for($count = 0; $count < count($callback_names); $count++) echo "Done"; ?> --EXPECT-- -*** Testing array_map() : non-permmited built-in functions *** --- Iteration 1 -- array_map(): Argument #1 ($callback) must be a valid callback or null, function "echo" not found or invalid function name --- Iteration 2 -- array_map(): Argument #1 ($callback) must be a valid callback or null, function "array" not found or invalid function name --- Iteration 3 -- array_map(): Argument #1 ($callback) must be a valid callback or null, function "empty" not found or invalid function name --- Iteration 4 -- array_map(): Argument #1 ($callback) must be a valid callback or null, function "eval" not found or invalid function name --- Iteration 5 -- -array_map(): Argument #1 ($callback) must be a valid callback or null, function "exit" not found or invalid function name --- Iteration 6 -- array_map(): Argument #1 ($callback) must be a valid callback or null, function "isset" not found or invalid function name --- Iteration 7 -- array_map(): Argument #1 ($callback) must be a valid callback or null, function "list" not found or invalid function name --- Iteration 8 -- array_map(): Argument #1 ($callback) must be a valid callback or null, function "print" not found or invalid function name Done diff --git a/ext/tokenizer/tests/001.phpt b/ext/tokenizer/tests/001.phpt index 52eb469a970f8..19018c7bdc94b 100644 --- a/ext/tokenizer/tests/001.phpt +++ b/ext/tokenizer/tests/001.phpt @@ -48,7 +48,6 @@ echo token_name(T_OBJECT_CAST), "\n"; echo token_name(T_BOOL_CAST), "\n"; echo token_name(T_UNSET_CAST), "\n"; echo token_name(T_NEW), "\n"; -echo token_name(T_EXIT), "\n"; echo token_name(T_IF), "\n"; echo token_name(T_ELSEIF), "\n"; echo token_name(T_ELSE), "\n"; @@ -172,7 +171,6 @@ T_OBJECT_CAST T_BOOL_CAST T_UNSET_CAST T_NEW -T_EXIT T_IF T_ELSEIF T_ELSE diff --git a/ext/tokenizer/tokenizer_data.c b/ext/tokenizer/tokenizer_data.c index 77b67de6b1c6e..37ff7f3a05824 100644 --- a/ext/tokenizer/tokenizer_data.c +++ b/ext/tokenizer/tokenizer_data.c @@ -53,7 +53,6 @@ char *get_token_type_name(int token_type) case T_INSTANCEOF: return "T_INSTANCEOF"; case T_NEW: return "T_NEW"; case T_CLONE: return "T_CLONE"; - case T_EXIT: return "T_EXIT"; case T_IF: return "T_IF"; case T_ELSEIF: return "T_ELSEIF"; case T_ELSE: return "T_ELSE"; diff --git a/ext/tokenizer/tokenizer_data.stub.php b/ext/tokenizer/tokenizer_data.stub.php index 42c69c4f82eff..c764b6a5339fc 100644 --- a/ext/tokenizer/tokenizer_data.stub.php +++ b/ext/tokenizer/tokenizer_data.stub.php @@ -132,11 +132,6 @@ * @cvalue T_CLONE */ const T_CLONE = UNKNOWN; -/** - * @var int - * @cvalue T_EXIT - */ -const T_EXIT = UNKNOWN; /** * @var int * @cvalue T_IF diff --git a/ext/tokenizer/tokenizer_data_arginfo.h b/ext/tokenizer/tokenizer_data_arginfo.h index 4363a46720afd..1e5aff4f711ed 100644 --- a/ext/tokenizer/tokenizer_data_arginfo.h +++ b/ext/tokenizer/tokenizer_data_arginfo.h @@ -1,5 +1,5 @@ /* This is a generated file, edit the .stub.php file instead. - * Stub hash: 1dd42ee5b5b818c5bd131b5c4bbb13c153d99499 */ + * Stub hash: 37ec5e3ce4361f6b3259e56978038f10b01ee555 */ static void register_tokenizer_data_symbols(int module_number) { @@ -29,7 +29,6 @@ static void register_tokenizer_data_symbols(int module_number) REGISTER_LONG_CONSTANT("T_INSTANCEOF", T_INSTANCEOF, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_NEW", T_NEW, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_CLONE", T_CLONE, CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("T_EXIT", T_EXIT, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_IF", T_IF, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_ELSEIF", T_ELSEIF, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_ELSE", T_ELSE, CONST_PERSISTENT); diff --git a/sapi/phpdbg/phpdbg_prompt.c b/sapi/phpdbg/phpdbg_prompt.c index b242e5345a180..5279e6d50348a 100644 --- a/sapi/phpdbg/phpdbg_prompt.c +++ b/sapi/phpdbg/phpdbg_prompt.c @@ -608,7 +608,6 @@ int phpdbg_skip_line_helper(void) /* {{{ */ { || opline->opcode == ZEND_RETURN || opline->opcode == ZEND_FAST_RET || opline->opcode == ZEND_GENERATOR_RETURN - || opline->opcode == ZEND_EXIT || opline->opcode == ZEND_YIELD || opline->opcode == ZEND_YIELD_FROM ) { @@ -652,7 +651,6 @@ static void phpdbg_seek_to_end(void) /* {{{ */ { case ZEND_RETURN: case ZEND_FAST_RET: case ZEND_GENERATOR_RETURN: - case ZEND_EXIT: case ZEND_YIELD: case ZEND_YIELD_FROM: zend_hash_index_update_ptr(&PHPDBG_G(seek), (zend_ulong) opline, (void *) opline);