From 855f008874f27d4561d2990ac4a0cddd9d6e0dd7 Mon Sep 17 00:00:00 2001 From: Derick Rethans Date: Tue, 31 Mar 2020 13:53:42 +0000 Subject: [PATCH 1/9] Update NEWS for PHP 7.4.5RC1 --- NEWS | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/NEWS b/NEWS index d053610f1ead2..360c7c392d33a 100644 --- a/NEWS +++ b/NEWS @@ -1,7 +1,7 @@ PHP NEWS ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| -?? ??? ????, PHP 7.4.5 +02 Apr 2020, PHP 7.4.5RC1 - Core: . Fixed bug #79364 (When copy empty array, next key is unspecified). (cmb) From 4f606b5b8de2e9a762e3218d8375c53d08bbdbc5 Mon Sep 17 00:00:00 2001 From: Stanislav Malyshev Date: Mon, 13 Apr 2020 21:09:15 -0700 Subject: [PATCH 2/9] Merge branch 'PHP-7.3' into PHP-7.4 * PHP-7.3: Fix bug #79465 - use unsigneds as indexes. Fix bug #79330 - make all execution modes consistent in rejecting \0 --- ext/standard/exec.c | 9 +++++++++ ext/standard/url.c | 4 ++-- 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/ext/standard/exec.c b/ext/standard/exec.c index 86b0a0a466917..db92ea724b677 100644 --- a/ext/standard/exec.c +++ b/ext/standard/exec.c @@ -537,6 +537,15 @@ PHP_FUNCTION(shell_exec) Z_PARAM_STRING(command, command_len) ZEND_PARSE_PARAMETERS_END(); + if (!command_len) { + php_error_docref(NULL, E_WARNING, "Cannot execute a blank command"); + RETURN_FALSE; + } + if (strlen(command) != command_len) { + php_error_docref(NULL, E_WARNING, "NULL byte detected. Possible attack"); + RETURN_FALSE; + } + #ifdef PHP_WIN32 if ((in=VCWD_POPEN(command, "rt"))==NULL) { #else diff --git a/ext/standard/url.c b/ext/standard/url.c index c88e7c6902f58..62ce107f77058 100644 --- a/ext/standard/url.c +++ b/ext/standard/url.c @@ -543,7 +543,7 @@ PHPAPI size_t php_url_decode(char *str, size_t len) #ifndef CHARSET_EBCDIC *dest = (char) php_htoi(data + 1); #else - *dest = os_toebcdic[(char) php_htoi(data + 1)]; + *dest = os_toebcdic[(unsigned char) php_htoi(data + 1)]; #endif data += 2; len -= 2; @@ -639,7 +639,7 @@ PHPAPI size_t php_raw_url_decode(char *str, size_t len) #ifndef CHARSET_EBCDIC *dest = (char) php_htoi(data + 1); #else - *dest = os_toebcdic[(char) php_htoi(data + 1)]; + *dest = os_toebcdic[(unsigned char) php_htoi(data + 1)]; #endif data += 2; len -= 2; From f10c944c3d7429d2597320f876725419665bf387 Mon Sep 17 00:00:00 2001 From: Derick Rethans Date: Tue, 14 Apr 2020 10:51:01 +0100 Subject: [PATCH 3/9] Update NEWS --- NEWS | 3 +++ 1 file changed, 3 insertions(+) diff --git a/NEWS b/NEWS index 360c7c392d33a..85458ef5b5d1c 100644 --- a/NEWS +++ b/NEWS @@ -45,8 +45,11 @@ PHP NEWS (cmb) - Standard: + . Fixed bug #79330 (shell_exec() silently truncates after a null byte). (stas) . Fixed bug #79410 (system() swallows last chunk if it is exactly 4095 bytes without newline). (Christian Schneider) + . Fixed bug #79465 (OOB Read in urldecode()). (stas) + - Zip: . Fixed Bug #79296 (ZipArchive::open fails on empty file). (Remi) From e5c5832df8dff95a9d34cea9dc184585964c2832 Mon Sep 17 00:00:00 2001 From: Derick Rethans Date: Tue, 14 Apr 2020 13:51:43 +0100 Subject: [PATCH 4/9] Update header --- NEWS | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/NEWS b/NEWS index 85458ef5b5d1c..dcdb0267ce3ed 100644 --- a/NEWS +++ b/NEWS @@ -1,7 +1,7 @@ PHP NEWS ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| -02 Apr 2020, PHP 7.4.5RC1 +?? ??? ????, PHP 7.4.5 - Core: . Fixed bug #79364 (When copy empty array, next key is unspecified). (cmb) From 787a1730640a8a971ce46b2269a1a88376d61c74 Mon Sep 17 00:00:00 2001 From: Derick Rethans Date: Tue, 14 Apr 2020 12:54:27 +0000 Subject: [PATCH 5/9] Update NEWS for PHP 7.4.5 --- NEWS | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/NEWS b/NEWS index dcdb0267ce3ed..69ef12d4ba9ac 100644 --- a/NEWS +++ b/NEWS @@ -1,7 +1,7 @@ PHP NEWS ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| -?? ??? ????, PHP 7.4.5 +16 Apr 2020, PHP 7.4.5 - Core: . Fixed bug #79364 (When copy empty array, next key is unspecified). (cmb) From ab4d1893fa762f1d73601de2644963a7501b1c95 Mon Sep 17 00:00:00 2001 From: Derick Rethans Date: Tue, 14 Apr 2020 12:54:28 +0000 Subject: [PATCH 6/9] Update versions for PHP 7.4.5 --- configure.ac | 2 +- main/php_version.h | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/configure.ac b/configure.ac index fd025d37c7827..2bfcc0d4c636c 100644 --- a/configure.ac +++ b/configure.ac @@ -17,7 +17,7 @@ dnl Basic autoconf initialization, generation of config.nice. dnl ---------------------------------------------------------------------------- AC_PREREQ([2.68]) -AC_INIT([PHP],[7.4.5-dev],[https://bugs.php.net],[php],[https://www.php.net]) +AC_INIT([PHP],[7.4.5],[https://bugs.php.net],[php],[https://www.php.net]) AC_CONFIG_SRCDIR([main/php_version.h]) AC_CONFIG_AUX_DIR([build]) AC_PRESERVE_HELP_ORDER diff --git a/main/php_version.h b/main/php_version.h index 78a44f7cf3a50..484514a3d80bc 100644 --- a/main/php_version.h +++ b/main/php_version.h @@ -3,6 +3,6 @@ #define PHP_MAJOR_VERSION 7 #define PHP_MINOR_VERSION 4 #define PHP_RELEASE_VERSION 5 -#define PHP_EXTRA_VERSION "-dev" -#define PHP_VERSION "7.4.5-dev" +#define PHP_EXTRA_VERSION "" +#define PHP_VERSION "7.4.5" #define PHP_VERSION_ID 70405 From f5c85f1133413b844bfd2b02ef29fca781ab4d73 Mon Sep 17 00:00:00 2001 From: Daniel Beardsley Date: Thu, 15 Nov 2018 15:38:59 -0700 Subject: [PATCH 7/9] README: update for our build --- README.md | 155 ++++++++---------------------------------------------- 1 file changed, 21 insertions(+), 134 deletions(-) diff --git a/README.md b/README.md index 6b9fe6e65ed67..12896ff049ded 100644 --- a/README.md +++ b/README.md @@ -1,134 +1,21 @@ - - -# The PHP Interpreter - -PHP is a popular general-purpose scripting language that is especially suited to -web development. Fast, flexible and pragmatic, PHP powers everything from your -blog to the most popular websites in the world. PHP is distributed under the PHP -License v3.01. - -[![Build status](https://travis-ci.org/php/php-src.svg?branch=master)](https://travis-ci.org/php/php-src) -[![Build status](https://ci.appveyor.com/api/projects/status/meyur6fviaxgdwdy?svg=true)](https://ci.appveyor.com/project/php/php-src) -[![Build Status](https://dev.azure.com/phpazuredevops/php/_apis/build/status/php.php-src?branchName=PHP-7.4)](https://dev.azure.com/phpazuredevops/php/_build/latest?definitionId=1&branchName=PHP-7.4) - -## Documentation - -The PHP manual is available at [php.net/docs](https://php.net/docs). - -## Installation - -### Prebuilt packages and binaries - -Prebuilt packages and binaries can be used to get up and running fast with PHP. - -For Windows, the PHP binaries can be obtained from -[windows.php.net](https://windows.php.net). After extracting the archive the -`*.exe` files are ready to use. - -For other systems, see the [installation chapter](https://php.net/install). - -### Building PHP source code - -*For Windows, see [Build your own PHP on Windows](https://wiki.php.net/internals/windows/stepbystepbuild_sdk_2).* - -PHP uses autotools on Unix systems to configure the build: - - ./buildconf - ./configure [options] - -*See `./configure -h` for configuration options.* - - make [options] - -*See `make -h` for make options.* - -The `-j` option shall set the maximum number of jobs `make` can use for the -build: - - make -j4 - -Shall run `make` with a maximum of 4 concurrent jobs: Generally the maximum -number of jobs should not exceed the number of cores available. - -## Testing PHP source code - -PHP ships with an extensive test suite, the command `make test` is used after -successful compilation of the sources to run this test suite. - -It is possible to run tests using multiple cores by setting `-jN` in -`TEST_PHP_ARGS`: - - make TEST_PHP_ARGS=-j4 test - -Shall run `make test` with a maximum of 4 concurrent jobs: Generally the maximum -number of jobs should not exceed the number of cores available. - -The [qa.php.net](https://qa.php.net) site provides more detailed info about -testing and quality assurance. - -## Installing PHP built from source - -After a successful build (and test), PHP may be installed with: - - make install - -Depending on your permissions and prefix, `make install` may need super user -permissions. - -## PHP extensions - -Extensions provide additional functionality on top of PHP. PHP consists of many -essential bundled extensions. Additional extensions can be found in the PHP -Extension Community Library - [PECL](https://pecl.php.net). - -## Contributing - -The PHP source code is located in the Git repository at -[git.php.net](https://git.php.net). Contributions are most welcome by forking -the [GitHub mirror repository](https://github.com/php/php-src) and sending a -pull request. - -Discussions are done on GitHub, but depending on the topic can also be relayed -to the official PHP developer mailing list internals@lists.php.net. - -New features require an RFC and must be accepted by the developers. See -[Request for comments - RFC](https://wiki.php.net/rfc) and -[Voting on PHP features](https://wiki.php.net/rfc/voting) for more information -on the process. - -Bug fixes **do not** require an RFC but require a bug tracker ticket. Open a -ticket at [bugs.php.net](https://bugs.php.net) and reference the bug id using -`#NNNNNN`. - - Fix #55371: get_magic_quotes_gpc() throws deprecation warning - - After removing magic quotes, the get_magic_quotes_gpc function caused a - deprecated warning. get_magic_quotes_gpc can be used to detect the - magic_quotes behavior and therefore should not raise a warning at any time. - The patch removes this warning. - -Pull requests are not merged directly on GitHub. All PRs will be pulled and -pushed through [git.php.net](https://git.php.net). See -[Git workflow](https://wiki.php.net/vcs/gitworkflow) for more details. - -### Guidelines for contributors - -See further documents in the repository for more information on how to -contribute: - -- [Contributing to PHP](/CONTRIBUTING.md) -- [PHP coding standards](/CODING_STANDARDS.md) -- [Mailinglist rules](/docs/mailinglist-rules.md) -- [PHP release process](/docs/release-process.md) - -## Credits - -For the list of people who've put work into PHP, please see the -[PHP credits page](https://php.net/credits.php). +The iFixit PHP Interpreter +=================== + +This is our custom fork of php with a small feature added (autoescaping for html) + +Updating to a new version +====================== + +1. Fetch the origin +2. Create a new branch at the git tag of the php release we want to use +3. Cherry-pick the commit that adds our feature + - Merging can be done too, but there are often far more conflicts +4. Deal with conflicts (usually few) +5. Ensure the copied (and slightly changed) functions in `Zend/zend_compile.c` + and `Zend/zend_vm_def.h` are just like their copied from counterparts. +6. git add the changes and continue the cherry-pick. +7. run `php Zend/zend_vm_gen.php` and commit the resultant files +8. Build php (using the build script in our infrastructure repo) on this + branch. +9. Try running some of the tests that have been added in our patch +10. Open a pull here into the `ifixit-production` branch. From cb6eb5c35a07c843e5b357884186d77e3a1a2981 Mon Sep 17 00:00:00 2001 From: Daniel Beardsley Date: Thu, 20 Jun 2019 16:13:23 -0700 Subject: [PATCH 8/9] PHP Templates: add optional autescaping to echo/ To use php as a robust templataing language, we must inject *some* logic between templates and their output. We have chosen to make all html = $html; } public function __toString() { return (string)$this->html; } public function jsonSerialize() { return $this->html; } } The auto-escaping system can be configured with an: __auto_escape_exempt_class="HtmlString" Which allows instances of `HtmlString` to pass straight through a template without being modified (skipping the html_entities call). Helper functions can now return html safely and consumers don't have to care if it is HTML or not because the auto-escaping system knows what to do. squash with big commit --- Zend/zend.c | 5 +++ Zend/zend.h | 2 ++ Zend/zend_ast.c | 1 + Zend/zend_ast.h | 1 + Zend/zend_compile.c | 22 ++++++++++++-- Zend/zend_globals.h | 4 +++ Zend/zend_language_parser.y | 2 +- Zend/zend_vm_def.h | 44 +++++++++++++++++++++++++++ main/main.c | 16 ++++++++++ php.ini-development | 18 +++++++++++ tests/lang/short_tags.005.phpt | 17 +++++++++++ tests/lang/short_tags.006.phpt | 40 ++++++++++++++++++++++++ tests/lang/short_tags_escape.001.phpt | 23 ++++++++++++++ 13 files changed, 191 insertions(+), 4 deletions(-) create mode 100644 tests/lang/short_tags.005.phpt create mode 100644 tests/lang/short_tags.006.phpt create mode 100644 tests/lang/short_tags_escape.001.phpt diff --git a/Zend/zend.c b/Zend/zend.c index a9ae03e624272..55a74ddb8a744 100644 --- a/Zend/zend.c +++ b/Zend/zend.c @@ -70,6 +70,7 @@ static uint32_t zend_version_info_length; ZEND_API zend_class_entry *zend_standard_class_def = NULL; ZEND_API size_t (*zend_printf)(const char *format, ...); ZEND_API zend_write_func_t zend_write; +ZEND_API zend_write_func_t zend_write_escape; ZEND_API FILE *(*zend_fopen)(const char *filename, zend_string **opened_path); ZEND_API int (*zend_stream_open_function)(const char *filename, zend_file_handle *handle); ZEND_API void (*zend_ticks_function)(int ticks); @@ -169,6 +170,9 @@ ZEND_INI_BEGIN() ZEND_INI_ENTRY("error_reporting", NULL, ZEND_INI_ALL, OnUpdateErrorReporting) STD_ZEND_INI_ENTRY("zend.assertions", "1", ZEND_INI_ALL, OnUpdateAssertions, assertions, zend_executor_globals, executor_globals) ZEND_INI_ENTRY3_EX("zend.enable_gc", "1", ZEND_INI_ALL, OnUpdateGCEnabled, NULL, NULL, NULL, zend_gc_enabled_displayer_cb) + STD_ZEND_INI_BOOLEAN("__auto_escape", "0", ZEND_INI_ALL, OnUpdateBool, __auto_escape, zend_executor_globals, executor_globals) + STD_ZEND_INI_ENTRY("__auto_escape_flags", "3", ZEND_INI_ALL, OnUpdateLong, __auto_escape_flags, zend_executor_globals, executor_globals) + STD_ZEND_INI_ENTRY("__auto_escape_exempt_class", "", ZEND_INI_ALL, OnUpdateString, __auto_escape_exempt_class, zend_executor_globals, executor_globals) STD_ZEND_INI_BOOLEAN("zend.multibyte", "0", ZEND_INI_PERDIR, OnUpdateBool, multibyte, zend_compiler_globals, compiler_globals) ZEND_INI_ENTRY("zend.script_encoding", NULL, ZEND_INI_ALL, OnUpdateScriptEncoding) STD_ZEND_INI_BOOLEAN("zend.detect_unicode", "1", ZEND_INI_ALL, OnUpdateBool, detect_unicode, zend_compiler_globals, compiler_globals) @@ -811,6 +815,7 @@ int zend_startup(zend_utility_functions *utility_functions) /* {{{ */ zend_error_cb = utility_functions->error_function; zend_printf = utility_functions->printf_function; zend_write = (zend_write_func_t) utility_functions->write_function; + zend_write_escape = (zend_write_func_t) utility_functions->write_escape_function; zend_fopen = utility_functions->fopen_function; if (!zend_fopen) { zend_fopen = zend_fopen_wrapper; diff --git a/Zend/zend.h b/Zend/zend.h index 94fd9a35597f1..cf0a882a21d9c 100644 --- a/Zend/zend.h +++ b/Zend/zend.h @@ -189,6 +189,7 @@ typedef struct _zend_utility_functions { void (*error_function)(int type, const char *error_filename, const uint32_t error_lineno, const char *format, va_list args) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 4, 0); size_t (*printf_function)(const char *format, ...) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 1, 2); size_t (*write_function)(const char *str, size_t str_length); + size_t (*write_escape_function)(const char *str, size_t str_length); FILE *(*fopen_function)(const char *filename, zend_string **opened_path); void (*message_handler)(zend_long message, const void *data); zval *(*get_configuration_directive)(zend_string *name); @@ -277,6 +278,7 @@ END_EXTERN_C() BEGIN_EXTERN_C() extern ZEND_API size_t (*zend_printf)(const char *format, ...) ZEND_ATTRIBUTE_PTR_FORMAT(printf, 1, 2); extern ZEND_API zend_write_func_t zend_write; +extern ZEND_API zend_write_func_t zend_write_escape; extern ZEND_API FILE *(*zend_fopen)(const char *filename, zend_string **opened_path); extern ZEND_API void (*zend_ticks_function)(int ticks); extern ZEND_API void (*zend_interrupt_function)(zend_execute_data *execute_data); diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c index 338ff09f76a31..68533ecba2291 100644 --- a/Zend/zend_ast.c +++ b/Zend/zend_ast.c @@ -1662,6 +1662,7 @@ static ZEND_COLD void zend_ast_export_ex(smart_str *str, zend_ast *ast, int prio goto tail_call; case ZEND_AST_HALT_COMPILER: APPEND_STR("__HALT_COMPILER()"); + case ZEND_AST_ECHO_ESCAPE: case ZEND_AST_ECHO: APPEND_NODE_1("echo"); case ZEND_AST_THROW: diff --git a/Zend/zend_ast.h b/Zend/zend_ast.h index fd6dd1677a450..db7000c48915a 100644 --- a/Zend/zend_ast.h +++ b/Zend/zend_ast.h @@ -97,6 +97,7 @@ enum _zend_ast_kind { ZEND_AST_REF, ZEND_AST_HALT_COMPILER, ZEND_AST_ECHO, + ZEND_AST_ECHO_ESCAPE, ZEND_AST_THROW, ZEND_AST_GOTO, ZEND_AST_BREAK, diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 0f948e000b438..fea4c9edc421f 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -4341,6 +4341,19 @@ void zend_compile_echo(zend_ast *ast) /* {{{ */ } /* }}} */ +void zend_compile_echo_escape(zend_ast *ast) /* {{{ */ +{ + zend_op *opline; + zend_ast *expr_ast = ast->child[0]; + + znode expr_node; + zend_compile_expr(&expr_node, expr_ast); + + opline = zend_emit_op(NULL, ZEND_ECHO_ESCAPE, &expr_node, NULL); + opline->extended_value = 0; +} +/* }}} */ + void zend_compile_throw(zend_ast *ast) /* {{{ */ { zend_ast *expr_ast = ast->child[0]; @@ -7668,7 +7681,7 @@ void zend_compile_assign_coalesce(znode *result, zend_ast *ast) /* {{{ */ } /* }}} */ -void zend_compile_print(znode *result, zend_ast *ast) /* {{{ */ +void zend_compile_print_escape(znode *result, zend_ast *ast) /* {{{ */ { zend_op *opline; zend_ast *expr_ast = ast->child[0]; @@ -7676,7 +7689,7 @@ void zend_compile_print(znode *result, zend_ast *ast) /* {{{ */ znode expr_node; zend_compile_expr(&expr_node, expr_ast); - opline = zend_emit_op(NULL, ZEND_ECHO, &expr_node, NULL); + opline = zend_emit_op(NULL, ZEND_ECHO_ESCAPE, &expr_node, NULL); opline->extended_value = 1; result->op_type = IS_CONST; @@ -8480,6 +8493,9 @@ void zend_compile_stmt(zend_ast *ast) /* {{{ */ case ZEND_AST_RETURN: zend_compile_return(ast); break; + case ZEND_AST_ECHO_ESCAPE: + zend_compile_echo_escape(ast); + break; case ZEND_AST_ECHO: zend_compile_echo(ast); break; @@ -8646,7 +8662,7 @@ void zend_compile_expr(znode *result, zend_ast *ast) /* {{{ */ zend_compile_assign_coalesce(result, ast); return; case ZEND_AST_PRINT: - zend_compile_print(result, ast); + zend_compile_print_escape(result, ast); return; case ZEND_AST_EXIT: zend_compile_exit(result, ast); diff --git a/Zend/zend_globals.h b/Zend/zend_globals.h index 2e9fff40ad2f0..23e9528eb5f79 100644 --- a/Zend/zend_globals.h +++ b/Zend/zend_globals.h @@ -240,6 +240,10 @@ struct _zend_executor_globals { zend_bool exception_ignore_args; + zend_bool __auto_escape; + long __auto_escape_flags; + char *__auto_escape_exempt_class; + void *reserved[ZEND_MAX_RESERVED_RESOURCES]; }; diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y index 56a354b9cce3d..3758de114a54a 100644 --- a/Zend/zend_language_parser.y +++ b/Zend/zend_language_parser.y @@ -845,7 +845,7 @@ echo_expr_list: | echo_expr { $$ = zend_ast_create_list(1, ZEND_AST_STMT_LIST, $1); } ; echo_expr: - expr { $$ = zend_ast_create(ZEND_AST_ECHO, $1); } + expr { $$ = zend_ast_create(ZEND_AST_ECHO_ESCAPE, $1); } ; for_exprs: diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 900c21c3d3469..6e321eb135b97 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -1763,6 +1763,50 @@ ZEND_VM_HANDLER(136, ZEND_ECHO, CONST|TMPVAR|CV, ANY) ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +// This is copied from ZEND_ECHO above with only a small part different +ZEND_VM_HANDLER(199, ZEND_ECHO_ESCAPE, CONST|TMPVAR|CV, ANY) +{ + USE_OPLINE + zend_free_op free_op1; + zval *z; + + SAVE_OPLINE(); + z = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R); + + if (Z_TYPE_P(z) == IS_STRING) { + zend_string *str = Z_STR_P(z); + + if (ZSTR_LEN(str) != 0) { + if (EG(__auto_escape)) { + zend_write_escape(ZSTR_VAL(str), ZSTR_LEN(str)); + } else { + zend_write(ZSTR_VAL(str), ZSTR_LEN(str)); + } + } + } else { + zend_string *str = zval_get_string_func(z); + + if (ZSTR_LEN(str) != 0) { + // ===== This part differs from ZEND_ECHO + // __auto_escape - If this is an object and it's not explicitly + // tagged as html, then use the escaping write function + ZVAL_DEREF(z); + if (EG(__auto_escape) && !(Z_TYPE_P(z) == IS_OBJECT && strcmp(ZSTR_VAL(Z_OBJ_P(z)->ce->name), EG(__auto_escape_exempt_class)) == 0)) { + zend_write_escape(ZSTR_VAL(str), ZSTR_LEN(str)); + } else { + zend_write(ZSTR_VAL(str), ZSTR_LEN(str)); + } + // ===== End differences from ZEND_ECHO + } else if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + } + zend_string_release_ex(str, 0); + } + + FREE_OP1(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + ZEND_VM_HELPER(zend_fetch_var_address_helper, CONST|TMPVAR|CV, UNUSED, int type) { USE_OPLINE diff --git a/main/main.c b/main/main.c index e1491db1fd18f..3fff82cf69963 100644 --- a/main/main.c +++ b/main/main.c @@ -1978,6 +1978,21 @@ PHPAPI void php_com_initialize(void) } /* }}} */ +/* {{{ php_escape_write + */ +static size_t php_escape_write(const char *str, size_t str_length) +{ + size_t written; + zend_string *escaped; + + escaped = php_escape_html_entities((unsigned char*)str, str_length, 0, EG(__auto_escape_flags), NULL); + written = php_output_write(ZSTR_VAL(escaped), ZSTR_LEN(escaped)); + zend_string_free(escaped); + return written; +} +/* }}} */ + + #ifdef ZTS /* {{{ core_globals_ctor */ @@ -2155,6 +2170,7 @@ int php_module_startup(sapi_module_struct *sf, zend_module_entry *additional_mod zuf.error_function = php_error_cb; zuf.printf_function = php_printf; zuf.write_function = php_output_write; + zuf.write_escape_function = php_escape_write; zuf.fopen_function = php_fopen_wrapper_for_zend; zuf.message_handler = php_message_handler_for_zend; zuf.get_configuration_directive = php_get_configuration_directive_for_zend; diff --git a/php.ini-development b/php.ini-development index 2c39ece23ca29..e40bb95b74eef 100644 --- a/php.ini-development +++ b/php.ini-development @@ -877,6 +877,24 @@ default_socket_timeout = 60 ; http://php.net/auto-detect-line-endings ;auto_detect_line_endings = Off +;;;;;;;;;;;;;;;;; +; Auto escaping ; +;;;;;;;;;;;;;;;;; + +; Whether to enable escaping of content from short php tags: ' its toString() will not be escaped and +; will be passed directly to stdout. +; Default is "" +;__auto_escape_exempt_class = "HtmlString" + ;;;;;;;;;;;;;;;;;;;;;; ; Dynamic Extensions ; ;;;;;;;;;;;;;;;;;;;;;; diff --git a/tests/lang/short_tags.005.phpt b/tests/lang/short_tags.005.phpt new file mode 100644 index 0000000000000..320c85df89dc5 --- /dev/null +++ b/tests/lang/short_tags.005.phpt @@ -0,0 +1,17 @@ +--TEST-- +Escaping with custom flags using short open tags __auto_escape: On +--INI-- +short_open_tag=on +__auto_escape=on +--FILE-- + + + + + + + +--EXPECT-- +both quotes should be escaped: " ' + now just double quotes: " ' + now neither quotes: " ' diff --git a/tests/lang/short_tags.006.phpt b/tests/lang/short_tags.006.phpt new file mode 100644 index 0000000000000..40210219453fb --- /dev/null +++ b/tests/lang/short_tags.006.phpt @@ -0,0 +1,40 @@ +--TEST-- +Auto-escaping with __auto_escape_exempt_class using short open tags __auto_escape: On +--INI-- +short_open_tag=on +__auto_escape=Off +__auto_escape_exempt_class=HtmlString +--FILE-- +html = $html; + } + + public function __toString() { + return $this->html; + } +} + +function byRef(&$byRef) {} +?> + + + + + + + + + + + + +--EXPECT-- +this ampersand shouldn't be escaped when autoescaping is off: & + this ampersand should be escaped when autoescaping is on: & +this ampersand shouldn't be escaped when using an Exempt class: & +Passing an Exempt class by reference should leave this uescaped: & + this ampersand should be escaped when using a non-Exempt class: & diff --git a/tests/lang/short_tags_escape.001.phpt b/tests/lang/short_tags_escape.001.phpt new file mode 100644 index 0000000000000..1a07ca4b9e1b5 --- /dev/null +++ b/tests/lang/short_tags_escape.001.phpt @@ -0,0 +1,23 @@ +--TEST-- +Escaping with short_open_tag: On, __auto_escape: On +--INI-- +short_open_tag=on +__auto_escape=on +--FILE-- +&'?> + +&'?> + +&\n"; +print "and even this \"<>&"; ?> + +But this shouldn't be escaped "<>& +&"); ?> +--EXPECT-- +this should be escaped "<>& +so should this "<>& +and so should this "<>& +and even this "<>& +But this shouldn't be escaped "<>& +and this shouldn't either "<>& From 2fa338f553dab96ddc8be61eb0f79419c67040c8 Mon Sep 17 00:00:00 2001 From: Daniel Beardsley Date: Thu, 16 Apr 2020 10:57:16 -0700 Subject: [PATCH 9/9] Auto-generated files: update The previous commit updated zend_vm_def and others that are used as inputs to these auto-generated files. Run php Zend/zend_vm_gen.php and commit the result. --- Zend/zend_vm_execute.h | 229 ++++++++-- Zend/zend_vm_handlers.h | 904 ++++++++++++++++++++-------------------- Zend/zend_vm_opcodes.c | 14 +- Zend/zend_vm_opcodes.h | 3 +- 4 files changed, 661 insertions(+), 489 deletions(-) diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 2fce1be298f07..7fb40d7929107 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -3330,6 +3330,49 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_O ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +// This is copied from ZEND_ECHO above with only a small part different +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_ESCAPE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + zval *z; + + SAVE_OPLINE(); + z = RT_CONSTANT(opline, opline->op1); + + if (Z_TYPE_P(z) == IS_STRING) { + zend_string *str = Z_STR_P(z); + + if (ZSTR_LEN(str) != 0) { + if (EG(__auto_escape)) { + zend_write_escape(ZSTR_VAL(str), ZSTR_LEN(str)); + } else { + zend_write(ZSTR_VAL(str), ZSTR_LEN(str)); + } + } + } else { + zend_string *str = zval_get_string_func(z); + + if (ZSTR_LEN(str) != 0) { + // ===== This part differs from ZEND_ECHO + // __auto_escape - If this is an object and it's not explicitly + // tagged as html, then use the escaping write function + ZVAL_DEREF(z); + if (EG(__auto_escape) && !(Z_TYPE_P(z) == IS_OBJECT && strcmp(ZSTR_VAL(Z_OBJ_P(z)->ce->name), EG(__auto_escape_exempt_class)) == 0)) { + zend_write_escape(ZSTR_VAL(str), ZSTR_LEN(str)); + } else { + zend_write(ZSTR_VAL(str), ZSTR_LEN(str)); + } + // ===== End differences from ZEND_ECHO + } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + } + zend_string_release_ex(str, 0); + } + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -13351,6 +13394,50 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +// This is copied from ZEND_ECHO above with only a small part different +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_ESCAPE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_free_op free_op1; + zval *z; + + SAVE_OPLINE(); + z = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC); + + if (Z_TYPE_P(z) == IS_STRING) { + zend_string *str = Z_STR_P(z); + + if (ZSTR_LEN(str) != 0) { + if (EG(__auto_escape)) { + zend_write_escape(ZSTR_VAL(str), ZSTR_LEN(str)); + } else { + zend_write(ZSTR_VAL(str), ZSTR_LEN(str)); + } + } + } else { + zend_string *str = zval_get_string_func(z); + + if (ZSTR_LEN(str) != 0) { + // ===== This part differs from ZEND_ECHO + // __auto_escape - If this is an object and it's not explicitly + // tagged as html, then use the escaping write function + ZVAL_DEREF(z); + if (EG(__auto_escape) && !(Z_TYPE_P(z) == IS_OBJECT && strcmp(ZSTR_VAL(Z_OBJ_P(z)->ce->name), EG(__auto_escape_exempt_class)) == 0)) { + zend_write_escape(ZSTR_VAL(str), ZSTR_LEN(str)); + } else { + zend_write(ZSTR_VAL(str), ZSTR_LEN(str)); + } + // ===== End differences from ZEND_ECHO + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + } + zend_string_release_ex(str, 0); + } + + zval_ptr_dtor_nogc(free_op1); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -36964,6 +37051,49 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCO ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +// This is copied from ZEND_ECHO above with only a small part different +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ECHO_ESCAPE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + zval *z; + + SAVE_OPLINE(); + z = EX_VAR(opline->op1.var); + + if (Z_TYPE_P(z) == IS_STRING) { + zend_string *str = Z_STR_P(z); + + if (ZSTR_LEN(str) != 0) { + if (EG(__auto_escape)) { + zend_write_escape(ZSTR_VAL(str), ZSTR_LEN(str)); + } else { + zend_write(ZSTR_VAL(str), ZSTR_LEN(str)); + } + } + } else { + zend_string *str = zval_get_string_func(z); + + if (ZSTR_LEN(str) != 0) { + // ===== This part differs from ZEND_ECHO + // __auto_escape - If this is an object and it's not explicitly + // tagged as html, then use the escaping write function + ZVAL_DEREF(z); + if (EG(__auto_escape) && !(Z_TYPE_P(z) == IS_OBJECT && strcmp(ZSTR_VAL(Z_OBJ_P(z)->ce->name), EG(__auto_escape_exempt_class)) == 0)) { + zend_write_escape(ZSTR_VAL(str), ZSTR_LEN(str)); + } else { + zend_write(ZSTR_VAL(str), ZSTR_LEN(str)); + } + // ===== End differences from ZEND_ECHO + } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + } + zend_string_release_ex(str, 0); + } + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -52701,6 +52831,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_LABEL, + (void*)&&ZEND_ECHO_ESCAPE_SPEC_CONST_LABEL, + (void*)&&ZEND_ECHO_ESCAPE_SPEC_TMPVAR_LABEL, + (void*)&&ZEND_ECHO_ESCAPE_SPEC_TMPVAR_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ECHO_ESCAPE_SPEC_CV_LABEL, (void*)&&ZEND_JMP_FORWARD_SPEC_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -53973,6 +54108,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_ECHO_SPEC_CONST) ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_ECHO_ESCAPE_SPEC_CONST): + VM_TRACE(ZEND_ECHO_ESCAPE_SPEC_CONST) + ZEND_ECHO_ESCAPE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_JMPZ_SPEC_CONST): VM_TRACE(ZEND_JMPZ_SPEC_CONST) ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -55131,6 +55270,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_ECHO_SPEC_TMPVAR) ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_ECHO_ESCAPE_SPEC_TMPVAR): + VM_TRACE(ZEND_ECHO_ESCAPE_SPEC_TMPVAR) + ZEND_ECHO_ESCAPE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_JMPZ_SPEC_TMPVAR): VM_TRACE(ZEND_JMPZ_SPEC_TMPVAR) ZEND_JMPZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -56827,6 +56970,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_ECHO_SPEC_CV) ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_ECHO_ESCAPE_SPEC_CV): + VM_TRACE(ZEND_ECHO_ESCAPE_SPEC_CV) + ZEND_ECHO_ESCAPE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_JMPZ_SPEC_CV): VM_TRACE(ZEND_JMPZ_SPEC_CV) ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -60238,6 +60385,11 @@ void zend_vm_init(void) ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER, + ZEND_ECHO_ESCAPE_SPEC_CONST_HANDLER, + ZEND_ECHO_ESCAPE_SPEC_TMPVAR_HANDLER, + ZEND_ECHO_ESCAPE_SPEC_TMPVAR_HANDLER, + ZEND_NULL_HANDLER, + ZEND_ECHO_ESCAPE_SPEC_CV_HANDLER, ZEND_JMP_FORWARD_SPEC_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, @@ -61328,7 +61480,12 @@ void zend_vm_init(void) 2280, 2281 | SPEC_RULE_OP1, 2286 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3203 + 3208, + 3208, + 3208, + 3208, + 2311 | SPEC_RULE_OP1, + 3208 }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -61520,7 +61677,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 = 2312 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2317 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -61528,7 +61685,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 = 2337 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2342 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -61536,7 +61693,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 = 2362 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2367 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -61547,17 +61704,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 = 2387 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2392 | 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 = 2412 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2417 | 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 = 2437 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2442 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -61568,17 +61725,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 = 2462 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2467 | 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 = 2487 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2492 | 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 = 2512 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2517 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -61589,12 +61746,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 = 2537 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2542 | 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 = 2612 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2617 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -61605,12 +61762,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 = 2687 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2692 | 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 = 2762 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2767 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -61618,12 +61775,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 = 2837 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 2842 | 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 = 2912 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 2917 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -61631,69 +61788,69 @@ 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 = 2987 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 2992 | 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 = 3062 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3067 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3149 | SPEC_RULE_OP1; - } else if (op1_info == MAY_BE_DOUBLE) { spec = 3154 | 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))))) { + } else if (op1_info == MAY_BE_DOUBLE) { spec = 3159 | 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 = 3164 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3137 | SPEC_RULE_RETVAL; + spec = 3142 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3139 | SPEC_RULE_RETVAL; + spec = 3144 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3141 | SPEC_RULE_RETVAL; + spec = 3146 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3143 | SPEC_RULE_RETVAL; + spec = 3148 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3145; + spec = 3150; } else if (op1_info == MAY_BE_LONG) { - spec = 3146; + spec = 3151; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3147; + spec = 3152; } else if (op1_info == MAY_BE_LONG) { - spec = 3148; + spec = 3153; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2311; + spec = 2316; } break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3199; + spec = 3204; } break; case ZEND_SEND_VAR_EX: if (op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3194 | SPEC_RULE_OP1; + spec = 3199 | SPEC_RULE_OP1; } break; case ZEND_FE_FETCH_R: if (op->op2_type == IS_CV && (op1_info & (MAY_BE_UNDEF|MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 3201 | SPEC_RULE_RETVAL; + spec = 3206 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -61701,17 +61858,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 = 3164 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3169 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_SEND_VAL_EX: if (op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3200; + spec = 3205; } break; case ZEND_SEND_VAR: if ((op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3189 | SPEC_RULE_OP1; + spec = 3194 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 7aa1a93981e35..50bdc7b5fcea1 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -1284,493 +1284,497 @@ _(2307, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ _(2308, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ _(2310, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ - _(2311, ZEND_JMP_FORWARD_SPEC) \ - _(2317, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2318, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2319, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2321, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2311, ZEND_ECHO_ESCAPE_SPEC_CONST) \ + _(2312, ZEND_ECHO_ESCAPE_SPEC_TMPVAR) \ + _(2313, ZEND_ECHO_ESCAPE_SPEC_TMPVAR) \ + _(2315, ZEND_ECHO_ESCAPE_SPEC_CV) \ + _(2316, ZEND_JMP_FORWARD_SPEC) \ _(2322, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2323, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2324, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2326, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2332, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2333, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2334, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2336, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2342, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2343, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2344, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2346, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2327, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2328, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2329, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2331, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2337, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2338, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2339, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2341, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2347, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(2348, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2349, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2351, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2357, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2358, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2359, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2361, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2367, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2368, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2369, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2371, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2352, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2353, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2354, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2356, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2362, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2363, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2364, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2366, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2372, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2373, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2374, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2376, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2382, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2383, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2384, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2386, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2388, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2389, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2391, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2392, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2393, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2394, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2396, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2377, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2378, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2379, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2381, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2387, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2388, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2389, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2391, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2393, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2394, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2396, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ _(2397, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2398, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2399, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2401, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2407, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2408, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2409, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2411, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2413, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2414, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2416, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2417, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2418, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2419, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2421, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2402, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2403, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2404, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2406, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2412, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2413, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2414, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2416, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2418, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2419, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2421, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ _(2422, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(2423, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2424, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2426, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2432, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2433, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2434, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2436, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2438, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2439, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2441, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2442, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2443, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2444, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2446, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2427, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2428, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2429, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2431, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2437, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2438, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2439, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2441, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2443, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2444, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2446, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ _(2447, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2448, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2449, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2451, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2457, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2458, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2459, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2461, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2467, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2468, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2469, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2471, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2452, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2453, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2454, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2456, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2462, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2463, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2464, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2466, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2472, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2473, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2474, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2476, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2482, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2483, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2484, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2486, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2492, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2493, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2494, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2496, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2477, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2478, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2479, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2481, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2487, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2488, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2489, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2491, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2497, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(2498, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2499, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2501, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2507, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2508, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2509, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2511, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2517, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2518, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2519, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2521, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2502, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2503, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2504, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2506, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2512, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2513, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2514, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2516, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2522, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2523, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2524, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2526, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2532, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2533, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2534, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2536, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2552, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2553, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2554, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2555, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2556, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2557, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2558, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2559, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2560, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2564, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2565, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2566, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2567, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2568, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2569, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2570, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2571, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2572, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2573, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2574, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2575, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2579, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2580, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2581, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2597, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2598, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2599, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2600, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2601, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2602, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2603, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2604, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2605, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2609, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2610, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2611, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2627, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2628, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2629, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2630, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2631, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2632, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2633, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2634, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2635, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2639, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2640, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2641, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2642, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2643, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2644, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2645, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2646, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2647, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2648, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2649, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2650, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2654, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2655, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2656, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2672, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2673, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2674, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2675, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2676, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2677, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2678, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2679, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2680, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2684, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2685, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2686, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2702, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2703, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2704, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2705, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2706, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2707, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2708, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2709, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2710, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2714, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2715, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2716, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2717, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2718, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2719, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2720, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2721, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2722, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2723, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2724, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2725, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2729, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2730, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2731, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2747, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2748, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2749, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2750, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2751, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2752, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2753, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2754, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2755, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2759, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2760, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2761, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2777, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2778, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2779, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2780, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2781, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2782, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2783, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2784, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2785, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2789, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2790, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2791, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2792, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2793, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2794, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2795, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2796, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2797, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2798, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2799, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2800, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2804, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2805, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2806, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2822, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2823, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2824, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2825, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2826, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2827, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2828, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2829, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2830, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2834, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2835, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2836, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2840, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(2841, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2842, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2843, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(2844, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2845, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2849, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(2850, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2851, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2852, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(2853, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2854, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2855, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2856, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2857, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2858, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2859, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2860, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2864, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2865, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2866, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2867, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(2868, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2869, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2870, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2871, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2872, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2873, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2874, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2875, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2879, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2880, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2881, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2897, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(2898, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2899, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2900, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2901, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2902, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2903, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2904, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2905, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2909, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2910, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2911, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2915, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2916, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2917, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2918, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2919, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2920, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2924, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2925, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2926, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2927, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2928, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2929, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2930, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2931, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2932, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2933, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2934, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2935, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2939, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2940, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2941, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2942, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2943, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2944, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2945, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2946, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2947, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2948, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2949, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2950, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2954, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2955, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2956, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2972, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2973, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2974, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2975, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2976, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2977, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2978, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2979, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2980, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2984, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2985, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2986, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2990, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(2991, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2992, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2993, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(2994, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2995, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2999, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3000, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3001, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3002, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3003, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3004, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3005, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3006, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3007, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3008, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3009, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3010, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3014, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3015, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3016, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3017, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3018, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3019, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3020, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3021, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3022, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3023, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3024, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3025, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3029, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3030, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3031, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3047, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3048, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3049, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3050, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3051, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3052, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3053, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3054, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3055, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3059, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3060, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3061, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3065, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3066, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3067, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3068, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3069, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3070, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3074, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3075, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3076, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3077, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3078, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3079, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3080, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3081, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3082, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3083, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3084, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3085, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3089, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3090, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3091, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3092, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3093, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3094, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3095, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3096, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3097, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3098, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3099, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3100, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3104, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3105, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3106, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3122, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3123, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3124, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3125, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3126, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3127, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3128, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3129, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3130, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3134, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3135, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3136, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3137, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3138, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3139, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3140, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3141, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3142, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3143, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3144, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3145, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3146, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3147, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3148, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3149, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ - _(3150, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3151, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3153, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3154, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(3155, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3156, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3158, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3159, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(3160, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3161, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3163, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3165, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3166, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3168, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3169, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3170, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3171, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3173, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(2527, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2528, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2529, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2531, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2537, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2538, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2539, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2541, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2557, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2558, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2559, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2560, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2561, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2562, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2563, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2564, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2565, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2569, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2570, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2571, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2572, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2573, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2574, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2575, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2576, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2577, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2578, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2579, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2580, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2584, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2585, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2586, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2602, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2603, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2604, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2605, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2606, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2607, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2608, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2609, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2610, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2614, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2615, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2616, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2632, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2633, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2634, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2635, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2636, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2637, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2638, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2639, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2640, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2644, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2645, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2646, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2647, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2648, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2649, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2650, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2651, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2652, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2653, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2654, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2655, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2659, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2660, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2661, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2677, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2678, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2679, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2680, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2681, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2682, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2683, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2684, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2685, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2689, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2690, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2691, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2707, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2708, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2709, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2710, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2711, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2712, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2713, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2714, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2715, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2719, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2720, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2721, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2722, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2723, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2724, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2725, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2726, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2727, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2728, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2729, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2730, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2734, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2735, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2736, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2752, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2753, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2754, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2755, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2756, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2757, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2758, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2759, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2760, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2764, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2765, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2766, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2782, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2783, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2784, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2785, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2786, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2787, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2788, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2789, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2790, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2794, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2795, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2796, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2797, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2798, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2799, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2800, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2801, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2802, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2803, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2804, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2805, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2809, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2810, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2811, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2827, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2828, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2829, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2830, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2831, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2832, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2833, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2834, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2835, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2839, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2840, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2841, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2845, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(2846, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2847, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2848, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(2849, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2850, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2854, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(2855, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2856, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2857, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(2858, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2859, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2860, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2861, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2862, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2863, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2864, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2865, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2869, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2870, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2871, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2872, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(2873, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2874, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2875, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2876, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2877, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2878, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2879, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2880, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2884, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2885, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2886, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2902, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(2903, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2904, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2905, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2906, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2907, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2908, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2909, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2910, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2914, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2915, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2916, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2920, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2921, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2922, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2923, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2924, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2925, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2929, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2930, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2931, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2932, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2933, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2934, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2935, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2936, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2937, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2938, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2939, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2940, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2944, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2945, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2946, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2947, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2948, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2949, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2950, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2951, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2952, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2953, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2954, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2955, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2959, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2960, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2961, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2977, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2978, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2979, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2980, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2981, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2982, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2983, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2984, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2985, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2989, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2990, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2991, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2995, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(2996, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2997, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2998, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(2999, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3000, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3004, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3005, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3006, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3007, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3008, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3009, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3010, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3011, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3012, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3013, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3014, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3015, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3019, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3020, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3021, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3022, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3023, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3024, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3025, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3026, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3027, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3028, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3029, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3030, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3034, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3035, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3036, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3052, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3053, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3054, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3055, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3056, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3057, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3058, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3059, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3060, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3064, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3065, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3066, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3070, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3071, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3072, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3073, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3074, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3075, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3079, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3080, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3081, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3082, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3083, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3084, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3085, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3086, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3087, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3088, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3089, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3090, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3094, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3095, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3096, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3097, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3098, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3099, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3100, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3101, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3102, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3103, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3104, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3105, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3109, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3110, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3111, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3127, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3128, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3129, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3130, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3131, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3132, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3133, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3134, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3135, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3139, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3140, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3141, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3142, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3143, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3144, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3145, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3146, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3147, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3148, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3149, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3150, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3151, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3152, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3153, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3154, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3155, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3156, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3158, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3159, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3160, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3161, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3163, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3164, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3165, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3166, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3168, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3170, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3171, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3173, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ _(3174, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ _(3175, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ _(3176, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ _(3178, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3184, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(3185, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3186, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3188, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3191, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3193, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3196, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \ - _(3198, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \ - _(3199, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3200, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3201, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3202, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3202+1, ZEND_NULL) + _(3179, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3180, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3181, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3183, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3189, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3190, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3191, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3193, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3196, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3198, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3201, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \ + _(3203, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \ + _(3204, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3205, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3206, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3207, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3207+1, ZEND_NULL) diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index 3290d760be64f..5ea1445bfc4a4 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -22,7 +22,7 @@ #include #include -static const char *zend_vm_opcodes_names[195] = { +static const char *zend_vm_opcodes_names[200] = { "ZEND_NOP", "ZEND_ADD", "ZEND_SUB", @@ -218,9 +218,14 @@ static const char *zend_vm_opcodes_names[195] = { "ZEND_GET_CALLED_CLASS", "ZEND_GET_TYPE", "ZEND_ARRAY_KEY_EXISTS", + NULL, + NULL, + NULL, + NULL, + "ZEND_ECHO_ESCAPE", }; -static uint32_t zend_vm_opcodes_flags[195] = { +static uint32_t zend_vm_opcodes_flags[200] = { 0x00000000, 0x00000b0b, 0x00000b0b, @@ -416,6 +421,11 @@ static uint32_t zend_vm_opcodes_flags[195] = { 0x00000101, 0x00000103, 0x00000707, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000000, + 0x00000007, }; ZEND_API const char* ZEND_FASTCALL zend_get_opcode_name(zend_uchar opcode) { diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h index d06f44e889cf3..84ceaa5c7e7b3 100644 --- a/Zend/zend_vm_opcodes.h +++ b/Zend/zend_vm_opcodes.h @@ -271,7 +271,8 @@ END_EXTERN_C() #define ZEND_GET_CALLED_CLASS 192 #define ZEND_GET_TYPE 193 #define ZEND_ARRAY_KEY_EXISTS 194 +#define ZEND_ECHO_ESCAPE 199 -#define ZEND_VM_LAST_OPCODE 194 +#define ZEND_VM_LAST_OPCODE 199 #endif