diff --git a/.github/actions/apk/action.yml b/.github/actions/apk/action.yml new file mode 100644 index 0000000000000..49e336aa0fecb --- /dev/null +++ b/.github/actions/apk/action.yml @@ -0,0 +1,61 @@ +name: apk +runs: + using: composite + steps: + - shell: sh + run: | + set -x + + apk update -q + apk add \ + util-linux \ + bash \ + sudo \ + build-base \ + autoconf \ + unzip \ + tar \ + bison \ + re2c \ + pkgconf \ + mysql-client \ + aspell-dev \ + hunspell-dev \ + hunspell-en \ + bzip2-dev \ + curl-dev \ + freetype-dev \ + gettext-dev \ + gnu-libiconv-dev \ + gmp-dev \ + icu-dev \ + icu-data-full \ + jpeg-dev \ + libffi-dev \ + libpng-dev \ + libsodium-dev \ + libwebp-dev \ + libxml2-dev \ + libxpm-dev \ + libxslt-dev \ + libzip-dev \ + oniguruma-dev \ + openssl-dev \ + readline-dev \ + sqlite-dev \ + tidyhtml-dev \ + krb5-dev \ + gdbm-dev \ + lmdb-dev \ + argon2-dev \ + enchant2-dev \ + enchant2-hunspell \ + freetds-dev \ + imap-dev \ + net-snmp-dev \ + openldap-dev \ + unixodbc-dev \ + postgresql14-dev \ + tzdata \ + musl-locales \ + musl-locales-lang diff --git a/.github/actions/configure-alpine/action.yml b/.github/actions/configure-alpine/action.yml new file mode 100644 index 0000000000000..fe02dacfcdaf6 --- /dev/null +++ b/.github/actions/configure-alpine/action.yml @@ -0,0 +1,79 @@ +name: ./configure +inputs: + configurationParameters: + default: '' + required: false + skipSlow: + default: false + required: false +runs: + using: composite + steps: + - shell: bash + run: | + set -x + ./buildconf --force + ./configure \ + --enable-option-checking=fatal \ + --prefix=/usr \ + --enable-phpdbg \ + --enable-fpm \ + --with-pdo-mysql=mysqlnd \ + --with-mysqli=mysqlnd \ + ${{ inputs.skipSlow == 'false' && '--with-pgsql' || '' }} \ + ${{ inputs.skipSlow == 'false' && '--with-pdo-pgsql' || '' }} \ + ${{ inputs.skipSlow == 'false' && '--with-pdo-sqlite' || '' }} \ + --enable-intl \ + --without-pear \ + --enable-gd \ + --with-jpeg \ + --with-webp \ + --with-freetype \ + --with-xpm \ + --enable-exif \ + --with-zip \ + --with-zlib \ + --enable-soap \ + --enable-xmlreader \ + --with-xsl \ + ${{ inputs.skipSlow == 'false' && '--with-tidy' || '' }} \ + --enable-sysvsem \ + --enable-sysvshm \ + --enable-shmop \ + --enable-pcntl \ + --with-readline \ + --enable-mbstring \ + --with-iconv=/usr \ + --with-curl \ + --with-gettext \ + --enable-sockets \ + --with-bz2 \ + --with-openssl \ + --with-gmp \ + --enable-bcmath \ + --enable-calendar \ + --enable-ftp \ + ${{ inputs.skipSlow == 'false' && '--with-enchant=/usr' || '' }} \ + --enable-sysvmsg \ + --with-ffi \ + --enable-zend-test \ + ${{ inputs.skipSlow == 'false' && '--enable-dl-test=shared' || '' }} \ + ${{ inputs.skipSlow == 'false' && '--with-ldap' || '' }} \ + ${{ inputs.skipSlow == 'false' && '--with-ldap-sasl' || '' }} \ + --with-password-argon2 \ + --with-mhash \ + --with-sodium \ + --enable-dba \ + --with-cdb \ + --enable-flatfile \ + --enable-inifile \ + --with-lmdb \ + --with-gdbm \ + ${{ inputs.skipSlow == 'false' && '--with-snmp' || '' }} \ + ${{ inputs.skipSlow == 'false' && '--with-unixODBC' || '' }} \ + ${{ inputs.skipSlow == 'false' && '--with-pdo-odbc=unixODBC,/usr' || '' }} \ + --with-config-file-path=/etc \ + --with-config-file-scan-dir=/etc/php.d \ + ${{ inputs.skipSlow == 'false' && '--with-pdo-dblib' || '' }} \ + --enable-werror \ + ${{ inputs.configurationParameters }} diff --git a/.github/actions/install-alpine/action.yml b/.github/actions/install-alpine/action.yml new file mode 100644 index 0000000000000..3bb26c8cf35d5 --- /dev/null +++ b/.github/actions/install-alpine/action.yml @@ -0,0 +1,10 @@ +name: Install +runs: + using: composite + steps: + - shell: bash + run: | + set -x + sudo make install + sudo mkdir -p /etc/php.d + sudo chmod 777 /etc/php.d diff --git a/.github/actions/test-alpine/action.yml b/.github/actions/test-alpine/action.yml new file mode 100644 index 0000000000000..e14e3176b8efd --- /dev/null +++ b/.github/actions/test-alpine/action.yml @@ -0,0 +1,25 @@ +name: Test +inputs: + runTestsParameters: + default: '' + required: false + jitType: + default: 'disable' + required: false +runs: + using: composite + steps: + - shell: bash + run: | + set -x + export SKIP_IO_CAPTURE_TESTS=1 + export STACK_LIMIT_DEFAULTS_CHECK=1 + sapi/cli/php run-tests.php -P -q ${{ inputs.runTestsParameters }} \ + -d opcache.jit=${{ inputs.jitType }} \ + -d opcache.jit_buffer_size=64M \ + -j$(nproc) \ + -g FAIL,BORK,LEAK,XLEAK \ + --no-progress \ + --show-diff \ + --show-slow 1000 \ + --set-timeout 120 diff --git a/.github/nightly_matrix.php b/.github/nightly_matrix.php index a5804eaa02456..f0603dd97d73e 100644 --- a/.github/nightly_matrix.php +++ b/.github/nightly_matrix.php @@ -121,6 +121,26 @@ function get_macos_matrix_include(array $branches) { return $jobs; } +function get_alpine_matrix_include(array $branches) { + $jobs = []; + foreach ($branches as $branch) { + if ([$branch['version']['major'], $branch['version']['minor']] < [8, 4]) { + continue; + } + $jobs[] = [ + 'name' => '_ASAN_UBSAN', + 'branch' => $branch, + 'debug' => true, + 'zts' => true, + 'asan' => true, + 'test_jit' => true, + 'configuration_parameters' => "CFLAGS='-fsanitize=undefined,address -fno-sanitize=function -DZEND_TRACK_ARENA_ALLOC' LDFLAGS='-fsanitize=undefined,address -fno-sanitize=function' CC=clang-17 CXX=clang++-17", + 'run_tests_parameters' => '--asan -x', + ]; + } + return $jobs; +} + function get_current_version(): array { $file = dirname(__DIR__) . '/main/php_version.h'; $content = file_get_contents($file); @@ -145,10 +165,12 @@ function get_current_version(): array { $matrix_include = get_matrix_include($branches); $windows_matrix_include = get_windows_matrix_include($branches); $macos_matrix_include = get_macos_matrix_include($branches); +$alpine_matrix_include = get_alpine_matrix_include($branches); $f = fopen(getenv('GITHUB_OUTPUT'), 'a'); fwrite($f, 'branches=' . json_encode($branches, JSON_UNESCAPED_SLASHES) . "\n"); fwrite($f, 'matrix-include=' . json_encode($matrix_include, JSON_UNESCAPED_SLASHES) . "\n"); fwrite($f, 'windows-matrix-include=' . json_encode($windows_matrix_include, JSON_UNESCAPED_SLASHES) . "\n"); fwrite($f, 'macos-matrix-include=' . json_encode($macos_matrix_include, JSON_UNESCAPED_SLASHES) . "\n"); +fwrite($f, 'alpine-matrix-include=' . json_encode($alpine_matrix_include, JSON_UNESCAPED_SLASHES) . "\n"); fclose($f); diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 6899045c196d8..d4da1fdc84eb0 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -15,6 +15,7 @@ jobs: matrix-include: ${{ steps.set-matrix.outputs.matrix-include }} windows-matrix-include: ${{ steps.set-matrix.outputs.windows-matrix-include }} macos-matrix-include: ${{ steps.set-matrix.outputs.macos-matrix-include }} + alpine-matrix-include: ${{ steps.set-matrix.outputs.alpine-matrix-include }} steps: - uses: actions/checkout@v4 with: @@ -39,6 +40,65 @@ jobs: uses: ./.github/actions/notify-slack with: token: ${{ secrets.ACTION_MONITORING_SLACK }} + ALPINE: + needs: GENERATE_MATRIX + if: ${{ needs.GENERATE_MATRIX.outputs.branches != '[]' }} + strategy: + fail-fast: false + matrix: + include: ${{ fromJson(needs.GENERATE_MATRIX.outputs.alpine-matrix-include) }} + name: "${{ matrix.branch.name }}_ALPINE_X64${{ matrix.name }}_${{ matrix.debug && 'DEBUG' || 'RELEASE' }}_${{ matrix.zts && 'ZTS' || 'NTS' }}" + runs-on: ubuntu-22.04 + container: + image: 'alpine:3.20.1' + steps: + - name: git checkout + uses: actions/checkout@v4 + with: + ref: ${{ matrix.branch.ref }} + - name: apk + uses: ./.github/actions/apk + - name: LLVM 17 (ASAN-only) + if: ${{ matrix.asan }} + # libclang_rt.asan-x86_64.a is provided by compiler-rt, and only for clang17: + # https://pkgs.alpinelinux.org/contents?file=libclang_rt.asan-x86_64.a&path=&name=&branch=v3.20 + run: | + apk add clang17 compiler-rt + - name: System info + run: | + echo "::group::Show host CPU info" + lscpu + echo "::endgroup::" + echo "::group::Show installed package versions" + apk list + echo "::endgroup::" + - name: ./configure + uses: ./.github/actions/configure-alpine + with: + configurationParameters: >- + ${{ matrix.configuration_parameters }} + --${{ matrix.debug && 'enable' || 'disable' }}-debug + --${{ matrix.zts && 'enable' || 'disable' }}-zts + skipSlow: ${{ matrix.asan }} + - name: make + run: make -j$(/usr/bin/nproc) >/dev/null + - name: make install + uses: ./.github/actions/install-alpine + - name: Test Tracing JIT + if: matrix.test_jit + uses: ./.github/actions/test-alpine + with: + jitType: tracing + runTestsParameters: >- + ${{ matrix.run_tests_parameters }} + -d zend_extension=opcache.so + -d opcache.enable_cli=1 + - name: Notify Slack + if: failure() + uses: ./.github/actions/notify-slack + with: + token: ${{ secrets.ACTION_MONITORING_SLACK }} + LINUX_X64: needs: GENERATE_MATRIX if: ${{ needs.GENERATE_MATRIX.outputs.branches != '[]' }} diff --git a/NEWS b/NEWS index 2c65e9799aba4..e76fa144dbe13 100644 --- a/NEWS +++ b/NEWS @@ -4,6 +4,18 @@ PHP NEWS - Core: . Exiting a namespace now clears seen symbols. (ilutov) + . The exit (and die) language constructs now behave more like a function. + They can be passed liked callables, are affected by the strict_types + declare statement, and now perform the usual type coercions instead of + casting any non-integer value to a string. + As such, passing invalid types to exit/die may now result in a TypeError + being thrown. (Girgias) + +- Hash: + . Fix GH-15384 (Build fails on Alpine / Musl for amd64). (timwolla) + +- Standard: + . php_uname() now throws ValueErrors on invalid inputs. (Girgias) 15 Aug 2024, PHP 8.4.0beta1 diff --git a/UPGRADING b/UPGRADING index bcf95365538b9..0932ba539d3ba 100644 --- a/UPGRADING +++ b/UPGRADING @@ -37,6 +37,13 @@ PHP 8.4 UPGRADE NOTES allowed, e.g. $ref = &$this->readonly. This was already forbidden for readonly initialization, and was an oversight in the "readonly reinitialization during cloning" implementation. + . The exit (and die) language constructs now behave more like a function. + They can be passed liked callables, are affected by the strict_types + declare statement, and now perform the usual type coercions instead of + casting any non-integer value to a string. + As such, passing invalid types to exit/die may now result in a TypeError + being thrown. + RFC: https://wiki.php.net/rfc/exit-as-function - DBA: . dba_open() and dba_popen() will now return a Dba\Connection @@ -193,6 +200,7 @@ PHP 8.4 UPGRADE NOTES $enclosure arguments are not one byte long, or if the $escape is not one byte long or the empty string. This aligns the behaviour to be identical to that of fputcsv() and fgetcsv(). + . php_uname() now throws ValueErrors on invalid inputs. - Tidy: . Failures in the constructor now throw exceptions rather than emitting diff --git a/Zend/Optimizer/block_pass.c b/Zend/Optimizer/block_pass.c index cd6dce6a5c10a..6fcbd04f12af5 100644 --- a/Zend/Optimizer/block_pass.c +++ b/Zend/Optimizer/block_pass.c @@ -868,7 +868,6 @@ static void zend_optimize_block(zend_basic_block *block, zend_op_array *op_array break; case ZEND_RETURN: - case ZEND_EXIT: if (opline->op1_type == IS_TMP_VAR) { src = VAR_SOURCE(opline->op1); if (src && src->opcode == ZEND_QM_ASSIGN) { @@ -1221,8 +1220,7 @@ static void zend_jmp_optimization(zend_basic_block *block, zend_op_array *op_arr target = op_array->opcodes + target_block->start; if ((target->opcode == ZEND_RETURN || target->opcode == ZEND_RETURN_BY_REF || - target->opcode == ZEND_GENERATOR_RETURN || - target->opcode == ZEND_EXIT) && + target->opcode == ZEND_GENERATOR_RETURN) && !(op_array->fn_flags & ZEND_ACC_HAS_FINALLY_BLOCK)) { /* JMP L, L: RETURN to immediate RETURN */ *last_op = *target; diff --git a/Zend/Optimizer/pass1.c b/Zend/Optimizer/pass1.c index 7543c15341c97..7c9f1c99a2820 100644 --- a/Zend/Optimizer/pass1.c +++ b/Zend/Optimizer/pass1.c @@ -331,7 +331,6 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) case ZEND_RETURN: case ZEND_RETURN_BY_REF: case ZEND_GENERATOR_RETURN: - case ZEND_EXIT: case ZEND_THROW: case ZEND_MATCH_ERROR: case ZEND_CATCH: diff --git a/Zend/Optimizer/pass3.c b/Zend/Optimizer/pass3.c index 93e431fece440..2cbd0e3406521 100644 --- a/Zend/Optimizer/pass3.c +++ b/Zend/Optimizer/pass3.c @@ -88,8 +88,7 @@ void zend_optimizer_pass3(zend_op_array *op_array, zend_optimizer_ctx *ctx) MAKE_NOP(opline); } else if ((target->opcode == ZEND_RETURN || target->opcode == ZEND_RETURN_BY_REF || - target->opcode == ZEND_GENERATOR_RETURN || - target->opcode == ZEND_EXIT) && + target->opcode == ZEND_GENERATOR_RETURN) && !(op_array->fn_flags & ZEND_ACC_HAS_FINALLY_BLOCK)) { /* JMP L, L: RETURN to immediate RETURN */ *opline = *target; diff --git a/Zend/Optimizer/zend_call_graph.c b/Zend/Optimizer/zend_call_graph.c index fd63f587336a3..abd5dac533137 100644 --- a/Zend/Optimizer/zend_call_graph.c +++ b/Zend/Optimizer/zend_call_graph.c @@ -162,10 +162,6 @@ ZEND_API void zend_analyze_calls(zend_arena **arena, zend_script *script, uint32 call_info->send_unpack = 1; } break; - case ZEND_EXIT: - /* In this case the DO_CALL opcode may have been dropped - * and caller_call_opline will be NULL. */ - break; } opline++; } diff --git a/Zend/Optimizer/zend_cfg.c b/Zend/Optimizer/zend_cfg.c index 2a0fe369cfc6a..a05cf6fb79235 100644 --- a/Zend/Optimizer/zend_cfg.c +++ b/Zend/Optimizer/zend_cfg.c @@ -302,7 +302,6 @@ ZEND_API void zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, } break; case ZEND_MATCH_ERROR: - case ZEND_EXIT: case ZEND_THROW: /* Don't treat THROW as terminator if it's used in expression context, * as we may lose live ranges when eliminating unreachable code. */ @@ -506,7 +505,6 @@ ZEND_API void zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, case ZEND_RETURN: case ZEND_RETURN_BY_REF: case ZEND_GENERATOR_RETURN: - case ZEND_EXIT: case ZEND_THROW: case ZEND_MATCH_ERROR: case ZEND_VERIFY_NEVER_TYPE: diff --git a/Zend/tests/arginfo_zpp_mismatch.inc b/Zend/tests/arginfo_zpp_mismatch.inc index 023bfefa5d501..5b2711fdb6303 100644 --- a/Zend/tests/arginfo_zpp_mismatch.inc +++ b/Zend/tests/arginfo_zpp_mismatch.inc @@ -6,6 +6,9 @@ function skipFunction($function): bool { || $function === 'readline' || $function === 'readline_read_history' || $function === 'readline_write_history' + /* terminates script */ + || $function === 'exit' + || $function === 'die' /* intentionally violate invariants */ || $function === 'zend_create_unterminated_string' || $function === 'zend_test_array_return' diff --git a/Zend/tests/die_string_cast_exception.phpt b/Zend/tests/die_string_cast_exception.phpt deleted file mode 100644 index 9893c3389f970..0000000000000 --- a/Zend/tests/die_string_cast_exception.phpt +++ /dev/null @@ -1,13 +0,0 @@ ---TEST-- -Bug #79777: String cast exception during die should be handled gracefully ---FILE-- - ---EXPECTF-- -Fatal error: Uncaught Error: Object of class stdClass could not be converted to string in %s:%d -Stack trace: -#0 {main} - thrown in %s on line %d diff --git a/Zend/tests/exit/ast_print_assert_die_const.phpt b/Zend/tests/exit/ast_print_assert_die_const.phpt new file mode 100644 index 0000000000000..7c576666abe4b --- /dev/null +++ b/Zend/tests/exit/ast_print_assert_die_const.phpt @@ -0,0 +1,16 @@ +--TEST-- +Printing AST of die "constant" via assert +--INI-- +zend.assertions=1 +--FILE-- +getMessage(), PHP_EOL; +} + +?> +--EXPECT-- +AssertionError: assert(0 && \exit()) diff --git a/Zend/tests/exit/ast_print_assert_die_function.phpt b/Zend/tests/exit/ast_print_assert_die_function.phpt new file mode 100644 index 0000000000000..c83aff6692738 --- /dev/null +++ b/Zend/tests/exit/ast_print_assert_die_function.phpt @@ -0,0 +1,16 @@ +--TEST-- +Printing AST of die function via assert +--INI-- +zend.assertions=1 +--FILE-- +getMessage(), PHP_EOL; +} + +?> +--EXPECT-- +AssertionError: assert(0 && \exit()) diff --git a/Zend/tests/exit/ast_print_assert_exit_const.phpt b/Zend/tests/exit/ast_print_assert_exit_const.phpt new file mode 100644 index 0000000000000..2f52ee37a42da --- /dev/null +++ b/Zend/tests/exit/ast_print_assert_exit_const.phpt @@ -0,0 +1,16 @@ +--TEST-- +Printing AST of exit "constant" via assert +--INI-- +zend.assertions=1 +--FILE-- +getMessage(), PHP_EOL; +} + +?> +--EXPECT-- +AssertionError: assert(0 && \exit()) diff --git a/Zend/tests/exit/ast_print_assert_exit_function.phpt b/Zend/tests/exit/ast_print_assert_exit_function.phpt new file mode 100644 index 0000000000000..e5fd5635faec0 --- /dev/null +++ b/Zend/tests/exit/ast_print_assert_exit_function.phpt @@ -0,0 +1,16 @@ +--TEST-- +Printing AST of exit function via assert +--INI-- +zend.assertions=1 +--FILE-- +getMessage(), PHP_EOL; +} + +?> +--EXPECT-- +AssertionError: assert(0 && \exit()) diff --git a/Zend/tests/exit/define_class_members_exit_die.phpt b/Zend/tests/exit/define_class_members_exit_die.phpt new file mode 100644 index 0000000000000..0a3816dc0d065 --- /dev/null +++ b/Zend/tests/exit/define_class_members_exit_die.phpt @@ -0,0 +1,37 @@ +--TEST-- +Can define die and exit as class methods, constants and property +--FILE-- +exit); +var_dump($o->die); +var_dump($o->exit()); +var_dump($o->die()); + +?> +--EXPECT-- +int(5) +int(10) +NULL +NULL +int(20) +int(15) diff --git a/Zend/tests/exit/define_die_constant.phpt b/Zend/tests/exit/define_die_constant.phpt new file mode 100644 index 0000000000000..393904d9356dd --- /dev/null +++ b/Zend/tests/exit/define_die_constant.phpt @@ -0,0 +1,12 @@ +--TEST-- +Attempting to define die constant +--FILE-- + +--EXPECTF-- +Parse error: syntax error, unexpected token "exit", expecting identifier in %s on line %d diff --git a/Zend/tests/exit/define_die_constant_namespace.phpt b/Zend/tests/exit/define_die_constant_namespace.phpt new file mode 100644 index 0000000000000..b68038ba10fb7 --- /dev/null +++ b/Zend/tests/exit/define_die_constant_namespace.phpt @@ -0,0 +1,14 @@ +--TEST-- +Attempting to define die constant in a namespace +--FILE-- + +--EXPECTF-- +Parse error: syntax error, unexpected token "exit", expecting identifier in %s on line %d diff --git a/Zend/tests/exit/define_die_function.phpt b/Zend/tests/exit/define_die_function.phpt new file mode 100644 index 0000000000000..4ea41d6ced5bd --- /dev/null +++ b/Zend/tests/exit/define_die_function.phpt @@ -0,0 +1,10 @@ +--TEST-- +Attempting to define die() function +--FILE-- + +--EXPECTF-- +Parse error: syntax error, unexpected token "exit", expecting "(" in %s on line %d diff --git a/Zend/tests/exit/define_die_function_namespace.phpt b/Zend/tests/exit/define_die_function_namespace.phpt new file mode 100644 index 0000000000000..fece46cb7acd6 --- /dev/null +++ b/Zend/tests/exit/define_die_function_namespace.phpt @@ -0,0 +1,14 @@ +--TEST-- +Attempting to define die() function in a namespace +--FILE-- + +--EXPECTF-- +Parse error: syntax error, unexpected token "exit", expecting "(" in %s on line %d diff --git a/Zend/tests/exit/define_exit_constant.phpt b/Zend/tests/exit/define_exit_constant.phpt new file mode 100644 index 0000000000000..33cd073401223 --- /dev/null +++ b/Zend/tests/exit/define_exit_constant.phpt @@ -0,0 +1,12 @@ +--TEST-- +Attempting to define exit constant +--FILE-- + +--EXPECTF-- +Parse error: syntax error, unexpected token "exit", expecting identifier in %s on line %d diff --git a/Zend/tests/exit/define_exit_constant_namespace.phpt b/Zend/tests/exit/define_exit_constant_namespace.phpt new file mode 100644 index 0000000000000..8d0097bb9da3c --- /dev/null +++ b/Zend/tests/exit/define_exit_constant_namespace.phpt @@ -0,0 +1,14 @@ +--TEST-- +Attempting to define exit constant in a namespace +--FILE-- + +--EXPECTF-- +Parse error: syntax error, unexpected token "exit", expecting identifier in %s on line %d diff --git a/Zend/tests/exit/define_exit_function.phpt b/Zend/tests/exit/define_exit_function.phpt new file mode 100644 index 0000000000000..4c406ef0d8905 --- /dev/null +++ b/Zend/tests/exit/define_exit_function.phpt @@ -0,0 +1,10 @@ +--TEST-- +Attempting to define exit() function +--FILE-- + +--EXPECTF-- +Parse error: syntax error, unexpected token "exit", expecting "(" in %s on line %d diff --git a/Zend/tests/exit/define_exit_function_namespace.phpt b/Zend/tests/exit/define_exit_function_namespace.phpt new file mode 100644 index 0000000000000..9ea785b0e53ba --- /dev/null +++ b/Zend/tests/exit/define_exit_function_namespace.phpt @@ -0,0 +1,12 @@ +--TEST-- +Attempting to define exit() function in a namespace +--FILE-- + +--EXPECTF-- +Parse error: syntax error, unexpected token "exit", expecting "(" in %s on line %d diff --git a/Zend/tests/exit/define_goto_label_die.phpt b/Zend/tests/exit/define_goto_label_die.phpt new file mode 100644 index 0000000000000..b94ee13fa0abe --- /dev/null +++ b/Zend/tests/exit/define_goto_label_die.phpt @@ -0,0 +1,14 @@ +--TEST-- +Attempting to define a goto label called die +--FILE-- + +--EXPECTF-- +Parse error: syntax error, unexpected token ":" in %s on line %d diff --git a/Zend/tests/exit/define_goto_label_die_with_jump.phpt b/Zend/tests/exit/define_goto_label_die_with_jump.phpt new file mode 100644 index 0000000000000..fc755d52a5794 --- /dev/null +++ b/Zend/tests/exit/define_goto_label_die_with_jump.phpt @@ -0,0 +1,14 @@ +--TEST-- +Attempting to define a goto label called die and jump to it +--FILE-- + +--EXPECTF-- +Parse error: syntax error, unexpected token "exit", expecting identifier in %s on line %d diff --git a/Zend/tests/exit/define_goto_label_exit.phpt b/Zend/tests/exit/define_goto_label_exit.phpt new file mode 100644 index 0000000000000..a72b6bac2d2a4 --- /dev/null +++ b/Zend/tests/exit/define_goto_label_exit.phpt @@ -0,0 +1,14 @@ +--TEST-- +Attempting to define a goto label called exit +--FILE-- + +--EXPECTF-- +Parse error: syntax error, unexpected token ":" in %s on line %d diff --git a/Zend/tests/exit/define_goto_label_exit_with_jump.phpt b/Zend/tests/exit/define_goto_label_exit_with_jump.phpt new file mode 100644 index 0000000000000..a810f2c44c2d8 --- /dev/null +++ b/Zend/tests/exit/define_goto_label_exit_with_jump.phpt @@ -0,0 +1,14 @@ +--TEST-- +Attempting to define a goto label called exit and jump to it +--FILE-- + +--EXPECTF-- +Parse error: syntax error, unexpected token "exit", expecting identifier in %s on line %d diff --git a/Zend/tests/exit/die_string_cast_exception.phpt b/Zend/tests/exit/die_string_cast_exception.phpt new file mode 100644 index 0000000000000..711b0de6322ce --- /dev/null +++ b/Zend/tests/exit/die_string_cast_exception.phpt @@ -0,0 +1,14 @@ +--TEST-- +Bug #79777: String cast exception during die should be handled gracefully +--FILE-- +getMessage(), PHP_EOL; +} + +?> +--EXPECT-- +exit(): Argument #1 ($code) must be of type string|int, stdClass given diff --git a/Zend/tests/exit/disabling_die.phpt b/Zend/tests/exit/disabling_die.phpt new file mode 100644 index 0000000000000..8d84067a9abda --- /dev/null +++ b/Zend/tests/exit/disabling_die.phpt @@ -0,0 +1,12 @@ +--TEST-- +Using disable_functions INI to remove die +--INI-- +disable_functions=die +--FILE-- + +--EXPECT-- +Warning: Cannot disable function die() in Unknown on line 0 diff --git a/Zend/tests/exit/disabling_exit.phpt b/Zend/tests/exit/disabling_exit.phpt new file mode 100644 index 0000000000000..a6cf277d38f72 --- /dev/null +++ b/Zend/tests/exit/disabling_exit.phpt @@ -0,0 +1,12 @@ +--TEST-- +Using disable_functions INI to remove exit +--INI-- +disable_functions=exit +--FILE-- + +--EXPECT-- +Warning: Cannot disable function exit() in Unknown on line 0 diff --git a/Zend/tests/exit/exit_as_function.phpt b/Zend/tests/exit/exit_as_function.phpt new file mode 100644 index 0000000000000..2953fadfa6d47 --- /dev/null +++ b/Zend/tests/exit/exit_as_function.phpt @@ -0,0 +1,42 @@ +--TEST-- +exit() as function +--FILE-- + +--EXPECT-- +string(4) "exit" +string(3) "die" +object(Closure)#1 (2) { + ["function"]=> + string(4) "exit" + ["parameter"]=> + array(1) { + ["$code"]=> + string(10) "" + } +} +object(Closure)#2 (2) { + ["function"]=> + string(4) "exit" + ["parameter"]=> + array(1) { + ["$code"]=> + string(10) "" + } +} diff --git a/Zend/tests/exit/exit_statements.phpt b/Zend/tests/exit/exit_statements.phpt new file mode 100644 index 0000000000000..6b3147156709f --- /dev/null +++ b/Zend/tests/exit/exit_statements.phpt @@ -0,0 +1,46 @@ +--TEST-- +Using exit/die as a statement/constant +--FILE-- +getMessage(), PHP_EOL; +} + +TEMPLATE; + + +$php = getenv('TEST_PHP_EXECUTABLE_ESCAPED'); +$command = $php . ' ' . escapeshellarg(FILE_PATH); + +foreach (['exit', 'die'] as $value) { + echo 'Using ', $value, ' as value:', PHP_EOL; + $output = []; + $content = str_replace('FUNCTION', $value, FILE_CONTENT); + file_put_contents(FILE_PATH, $content); + exec($command, $output, $exit_status); + echo 'Exit status is: ', $exit_status, PHP_EOL, + 'Output is:', PHP_EOL, join($output), PHP_EOL; +} + +?> +--CLEAN-- + +--EXPECT-- +Using exit as value: +Exit status is: 0 +Output is: +Before exit +Using die as value: +Exit status is: 0 +Output is: +Before die diff --git a/Zend/tests/exit/exit_string_with_buffer_output.phpt b/Zend/tests/exit/exit_string_with_buffer_output.phpt new file mode 100644 index 0000000000000..a9ed44893cebc --- /dev/null +++ b/Zend/tests/exit/exit_string_with_buffer_output.phpt @@ -0,0 +1,23 @@ +--TEST-- +Throwing output buffer with exit("Message") +--FILE-- +getMessage(), PHP_EOL; +} +echo "After?\n"; + +?> +--EXPECT-- +Handler: Hello world! +Hello world! +Exception: test +After? diff --git a/Zend/tests/exit/exit_values.phpt b/Zend/tests/exit/exit_values.phpt new file mode 100644 index 0000000000000..e081193b94cd2 --- /dev/null +++ b/Zend/tests/exit/exit_values.phpt @@ -0,0 +1,183 @@ +--TEST-- +exit(false); +--FILE-- +getMessage(), PHP_EOL; +} + +TEMPLATE; + +$php = getenv('TEST_PHP_EXECUTABLE_ESCAPED'); +$command = $php . ' ' . escapeshellarg(FILE_PATH); + +foreach ([FILE_CONTENT, str_replace('exit', 'die', FILE_CONTENT)] as $code) { + foreach ($values as $value) { + echo 'Using ', zend_test_var_export($value), ' as value:', PHP_EOL; + $output = []; + $content = str_replace('VALUE', zend_test_var_export($value), $code); + file_put_contents(FILE_PATH, $content); + exec($command, $output, $exit_status); + echo 'Exit status is: ', $exit_status, PHP_EOL, + 'Output is:', PHP_EOL, join($output), PHP_EOL; + } + + echo 'As a statement:', PHP_EOL; + $output = []; + $content = str_replace('(VALUE)', '', $code); + exec($command, $output, $exit_status); + echo 'Exit status is: ', $exit_status, PHP_EOL, + 'Output is:', PHP_EOL, join($output), PHP_EOL; +} + +?> +--CLEAN-- + +--EXPECTF-- +Using NULL as value: +Exit status is: 0 +Output is: +Deprecated: exit(): Passing null to parameter #1 ($code) of type string|int is deprecated in %s on line %d +Using false as value: +Exit status is: 0 +Output is: + +Using true as value: +Exit status is: 1 +Output is: + +Using 0 as value: +Exit status is: 0 +Output is: + +Using 1 as value: +Exit status is: 1 +Output is: + +Using 20 as value: +Exit status is: 20 +Output is: + +Using 10.0 as value: +Exit status is: 10 +Output is: + +Using 15.5 as value: +Exit status is: 15 +Output is: +Deprecated: Implicit conversion from float 15.5 to int loses precision in %s on line %d +Using 'Hello world' as value: +Exit status is: 0 +Output is: +Hello world +Using [] as value: +Exit status is: 0 +Output is: +TypeError: exit(): Argument #1 ($code) must be of type string|int, array given +Using STDERR as value: +Exit status is: 0 +Output is: +TypeError: exit(): Argument #1 ($code) must be of type string|int, resource given +Using new stdClass() as value: +Exit status is: 0 +Output is: +TypeError: exit(): Argument #1 ($code) must be of type string|int, stdClass given +As a statement: +Exit status is: 0 +Output is: +TypeError: exit(): Argument #1 ($code) must be of type string|int, stdClass given +Using NULL as value: +Exit status is: 0 +Output is: +Deprecated: exit(): Passing null to parameter #1 ($code) of type string|int is deprecated in %s on line %d +Using false as value: +Exit status is: 0 +Output is: + +Using true as value: +Exit status is: 1 +Output is: + +Using 0 as value: +Exit status is: 0 +Output is: + +Using 1 as value: +Exit status is: 1 +Output is: + +Using 20 as value: +Exit status is: 20 +Output is: + +Using 10.0 as value: +Exit status is: 10 +Output is: + +Using 15.5 as value: +Exit status is: 15 +Output is: +Deprecated: Implicit conversion from float 15.5 to int loses precision in %s on line %d +Using 'Hello world' as value: +Exit status is: 0 +Output is: +Hello world +Using [] as value: +Exit status is: 0 +Output is: +TypeError: exit(): Argument #1 ($code) must be of type string|int, array given +Using STDERR as value: +Exit status is: 0 +Output is: +TypeError: exit(): Argument #1 ($code) must be of type string|int, resource given +Using new stdClass() as value: +Exit status is: 0 +Output is: +TypeError: exit(): Argument #1 ($code) must be of type string|int, stdClass given +As a statement: +Exit status is: 0 +Output is: +TypeError: exit(): Argument #1 ($code) must be of type string|int, stdClass given diff --git a/Zend/zend.c b/Zend/zend.c index ef5ea8cebc78b..9f6e709efbecf 100644 --- a/Zend/zend.c +++ b/Zend/zend.c @@ -1410,7 +1410,7 @@ ZEND_API ZEND_COLD void zend_error_zstr_at( zval retval; zval orig_user_error_handler; bool in_compilation; - zend_class_entry *saved_class_entry; + zend_class_entry *saved_class_entry = NULL; zend_stack loop_var_stack; zend_stack delayed_oplines_stack; int type = orig_type & E_ALL; diff --git a/Zend/zend_API.c b/Zend/zend_API.c index daa98a89253d8..229af38c2a8c4 100644 --- a/Zend/zend_API.c +++ b/Zend/zend_API.c @@ -3605,6 +3605,13 @@ ZEND_API zend_result zend_set_hash_symbol(zval *symbol, const char *name, size_t static void zend_disable_function(const char *function_name, size_t function_name_length) { + if (UNEXPECTED( + (function_name_length == strlen("exit") && !memcmp(function_name, "exit", strlen("exit"))) + || (function_name_length == strlen("die") && !memcmp(function_name, "die", strlen("die"))) + )) { + zend_error(E_WARNING, "Cannot disable function %s()", function_name); + return; + } zend_hash_str_del(CG(function_table), function_name, function_name_length); } diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c index 23bc5f7a3cd57..0335d2498acca 100644 --- a/Zend/zend_builtin_functions.c +++ b/Zend/zend_builtin_functions.c @@ -69,6 +69,33 @@ zend_result zend_startup_builtin_functions(void) /* {{{ */ } /* }}} */ +ZEND_FUNCTION(exit) +{ + zend_string *str = NULL; + zend_long code = 0; + + ZEND_PARSE_PARAMETERS_START(0, 1) + Z_PARAM_OPTIONAL + Z_PARAM_STR_OR_LONG(str, code) + ZEND_PARSE_PARAMETERS_END(); + + if (str) { + size_t len = ZSTR_LEN(str); + if (len != 0) { + /* An exception might be emitted by an output handler */ + zend_write(ZSTR_VAL(str), len); + if (EG(exception)) { + RETURN_THROWS(); + } + } + } else { + EG(exit_status) = code; + } + + ZEND_ASSERT(!EG(exception)); + zend_throw_unwind_exit(); +} + /* {{{ Get the version of the Zend Engine */ ZEND_FUNCTION(zend_version) { diff --git a/Zend/zend_builtin_functions.stub.php b/Zend/zend_builtin_functions.stub.php index b92b80b917c54..ddf12e117966f 100644 --- a/Zend/zend_builtin_functions.stub.php +++ b/Zend/zend_builtin_functions.stub.php @@ -7,6 +7,11 @@ class stdClass { } +function exit(string|int $code = 0): never {} + +/** @alias exit */ +function die(string|int $code = 0): never {} + /** @refcount 1 */ function zend_version(): string {} diff --git a/Zend/zend_builtin_functions_arginfo.h b/Zend/zend_builtin_functions_arginfo.h index 20e6f0f9b48a3..db9f325c63f00 100644 --- a/Zend/zend_builtin_functions_arginfo.h +++ b/Zend/zend_builtin_functions_arginfo.h @@ -1,5 +1,11 @@ /* This is a generated file, edit the .stub.php file instead. - * Stub hash: c3bec3b17079456ef17e5c992995dcfbe62c6fe0 */ + * Stub hash: a6d7e59d6b7875ddc28ce828ae240c7dfd852023 */ + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_exit, 0, 0, IS_NEVER, 0) + ZEND_ARG_TYPE_MASK(0, code, MAY_BE_STRING|MAY_BE_LONG, "0") +ZEND_END_ARG_INFO() + +#define arginfo_die arginfo_exit ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zend_version, 0, 0, IS_STRING, 0) ZEND_END_ARG_INFO() @@ -232,6 +238,7 @@ static const zend_frameless_function_info frameless_function_infos_class_exists[ { 0 }, }; +ZEND_FUNCTION(exit); ZEND_FUNCTION(zend_version); ZEND_FUNCTION(func_num_args); ZEND_FUNCTION(func_get_arg); @@ -292,6 +299,8 @@ ZEND_FUNCTION(gc_disable); ZEND_FUNCTION(gc_status); static const zend_function_entry ext_functions[] = { + ZEND_FE(exit, arginfo_exit) + ZEND_RAW_FENTRY("die", zif_exit, arginfo_die, 0, NULL, NULL) ZEND_FE(zend_version, arginfo_zend_version) ZEND_FE(func_num_args, arginfo_func_num_args) ZEND_FE(func_get_arg, arginfo_func_get_arg) diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index cfd97e59b7ebd..9e736ea1b37ad 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -10376,27 +10376,6 @@ static void zend_compile_print(znode *result, zend_ast *ast) /* {{{ */ } /* }}} */ -static void zend_compile_exit(znode *result, zend_ast *ast) /* {{{ */ -{ - zend_ast *expr_ast = ast->child[0]; - znode expr_node; - - if (expr_ast) { - zend_compile_expr(&expr_node, expr_ast); - } else { - expr_node.op_type = IS_UNUSED; - } - - zend_op *opline = zend_emit_op(NULL, ZEND_EXIT, &expr_node, NULL); - if (result) { - /* Mark this as an "expression throw" for opcache. */ - opline->extended_value = ZEND_THROW_IS_EXPR; - result->op_type = IS_CONST; - ZVAL_TRUE(&result->u.constant); - } -} -/* }}} */ - static void zend_compile_yield(znode *result, zend_ast *ast) /* {{{ */ { zend_ast *value_ast = ast->child[0]; @@ -11366,7 +11345,6 @@ static void zend_compile_stmt(zend_ast *ast) /* {{{ */ zend_compile_halt_compiler(ast); break; case ZEND_AST_THROW: - case ZEND_AST_EXIT: zend_compile_expr(NULL, ast); break; default: @@ -11469,9 +11447,6 @@ static void zend_compile_expr_inner(znode *result, zend_ast *ast) /* {{{ */ case ZEND_AST_PRINT: zend_compile_print(result, ast); return; - case ZEND_AST_EXIT: - zend_compile_exit(result, ast); - return; case ZEND_AST_YIELD: zend_compile_yield(result, ast); return; diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y index f7822caa88dc3..5423d40185766 100644 --- a/Zend/zend_language_parser.y +++ b/Zend/zend_language_parser.y @@ -258,7 +258,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %type absolute_trait_method_reference trait_method_reference property echo_expr %type new_dereferenceable new_non_dereferenceable anonymous_class class_name class_name_reference simple_variable %type internal_functions_in_yacc -%type exit_expr scalar backticks_expr lexical_var function_call member_name property_name +%type scalar backticks_expr lexical_var function_call member_name property_name %type variable_class_name dereferenceable_scalar constant class_constant %type fully_dereferenceable array_object_dereferenceable %type callable_expr callable_variable static_member new_variable @@ -1304,7 +1304,11 @@ expr: | T_OBJECT_CAST expr { $$ = zend_ast_create_cast(IS_OBJECT, $2); } | T_BOOL_CAST expr { $$ = zend_ast_create_cast(_IS_BOOL, $2); } | T_UNSET_CAST expr { $$ = zend_ast_create_cast(IS_NULL, $2); } - | T_EXIT exit_expr { $$ = zend_ast_create(ZEND_AST_EXIT, $2); } + | T_EXIT ctor_arguments { + zend_ast *name = zend_ast_create_zval_from_str(ZSTR_KNOWN(ZEND_STR_EXIT)); + name->attr = ZEND_NAME_FQ; + $$ = zend_ast_create(ZEND_AST_CALL, name, $2); + } | '@' expr { $$ = zend_ast_create(ZEND_AST_SILENCE, $2); } | scalar { $$ = $1; } | '`' backticks_expr '`' { $$ = zend_ast_create(ZEND_AST_SHELL_EXEC, $2); } @@ -1407,11 +1411,6 @@ class_name_reference: | '(' expr ')' { $$ = $2; } ; -exit_expr: - %empty { $$ = NULL; } - | '(' optional_expr ')' { $$ = $2; } -; - backticks_expr: %empty { $$ = zend_ast_create_zval_from_str(ZSTR_EMPTY_ALLOC()); } diff --git a/Zend/zend_string.h b/Zend/zend_string.h index b62875a6ec1ce..ad6c5e1ee38bf 100644 --- a/Zend/zend_string.h +++ b/Zend/zend_string.h @@ -572,6 +572,7 @@ EMPTY_SWITCH_DEFAULT_CASE() _(ZEND_STR_ARGS, "args") \ _(ZEND_STR_UNKNOWN, "unknown") \ _(ZEND_STR_UNKNOWN_CAPITALIZED, "Unknown") \ + _(ZEND_STR_EXIT, "exit") \ _(ZEND_STR_EVAL, "eval") \ _(ZEND_STR_INCLUDE, "include") \ _(ZEND_STR_REQUIRE, "require") \ diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index c99cc9c1a2f65..55fdb7d46582b 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -7610,38 +7610,6 @@ ZEND_VM_C_LABEL(array_key_exists_array): ZEND_VM_SMART_BRANCH(result, 1); } -/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */ -ZEND_VM_COLD_HANDLER(79, ZEND_EXIT, ANY, ANY) -{ - USE_OPLINE - - SAVE_OPLINE(); - if (OP1_TYPE != IS_UNUSED) { - zval *ptr = GET_OP1_ZVAL_PTR(BP_VAR_R); - - do { - if (Z_TYPE_P(ptr) == IS_LONG) { - EG(exit_status) = Z_LVAL_P(ptr); - } else { - if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(ptr)) { - ptr = Z_REFVAL_P(ptr); - if (Z_TYPE_P(ptr) == IS_LONG) { - EG(exit_status) = Z_LVAL_P(ptr); - break; - } - } - zend_print_zval(ptr, 0); - } - } while (0); - FREE_OP1(); - } - - if (!EG(exception)) { - zend_throw_unwind_exit(); - } - HANDLE_EXCEPTION(); -} - ZEND_VM_HANDLER(57, ZEND_BEGIN_SILENCE, ANY, ANY) { USE_OPLINE diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 75499f028e2cd..16455b6e0cd58 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -3013,37 +3013,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXIT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - - SAVE_OPLINE(); - if (opline->op1_type != IS_UNUSED) { - zval *ptr = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R); - - do { - if (Z_TYPE_P(ptr) == IS_LONG) { - EG(exit_status) = Z_LVAL_P(ptr); - } else { - if ((opline->op1_type & (IS_VAR|IS_CV)) && Z_ISREF_P(ptr)) { - ptr = Z_REFVAL_P(ptr); - if (Z_TYPE_P(ptr) == IS_LONG) { - EG(exit_status) = Z_LVAL_P(ptr); - break; - } - } - zend_print_zval(ptr, 0); - } - } while (0); - FREE_OP(opline->op1_type, opline->op1.var); - } - - if (!EG(exception)) { - zend_throw_unwind_exit(); - } - HANDLE_EXCEPTION(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -7930,7 +7899,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CO ZEND_VM_SMART_BRANCH(result, 1); } -/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -10307,7 +10275,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TM ZEND_VM_SMART_BRANCH(result, 1); } -/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -12788,7 +12755,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV ZEND_VM_SMART_BRANCH(result, 1); } -/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -16950,7 +16916,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_C ZEND_VM_SMART_BRANCH(result, 1); } -/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -18417,7 +18382,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_T ZEND_VM_SMART_BRANCH(result, 1); } -/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -19824,7 +19788,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_C ZEND_VM_SMART_BRANCH(result, 1); } -/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -45235,7 +45198,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST ZEND_VM_SMART_BRANCH(result, 1); } -/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -48963,7 +48925,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVA ZEND_VM_SMART_BRANCH(result, 1); } -/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -54527,7 +54488,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HA ZEND_VM_SMART_BRANCH(result, 1); } -/* No specialization for op_types (CONST|TMPVAR|UNUSED|CV, ANY) */ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -56322,7 +56282,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FE_RESET_R_SPEC_CV_LABEL, (void*)&&ZEND_FE_FETCH_R_SPEC_VAR_LABEL, - (void*)&&ZEND_EXIT_SPEC_LABEL, (void*)&&ZEND_FETCH_R_SPEC_CONST_UNUSED_LABEL, (void*)&&ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_LABEL, (void*)&&ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_LABEL, @@ -58572,11 +58531,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) HYBRID_BREAK(); - HYBRID_CASE(ZEND_EXIT_SPEC): - VM_TRACE(ZEND_EXIT_SPEC) - ZEND_EXIT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_EXIT_SPEC) - HYBRID_BREAK(); HYBRID_CASE(ZEND_BEGIN_SILENCE_SPEC): VM_TRACE(ZEND_BEGIN_SILENCE_SPEC) ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -65515,7 +65469,6 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_FE_RESET_R_SPEC_CV_HANDLER, ZEND_FE_FETCH_R_SPEC_VAR_HANDLER, - ZEND_EXIT_SPEC_HANDLER, ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER, @@ -67460,7 +67413,7 @@ void zend_vm_init(void) 1255, 1256 | SPEC_RULE_OP1, 1261 | SPEC_RULE_OP1, - 3487, + 3486, 1266 | SPEC_RULE_OP1, 1271 | SPEC_RULE_OP1, 1276 | SPEC_RULE_OP2, @@ -67494,100 +67447,101 @@ void zend_vm_init(void) 1559 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 1584 | SPEC_RULE_OP1, 1589, - 1590, - 1591 | SPEC_RULE_OP1, - 1596 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1621 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1646 | SPEC_RULE_OP1, - 1651 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1676 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1701 | SPEC_RULE_OP1, - 1706 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1731 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1756 | SPEC_RULE_OP1, - 1761 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1786 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1811 | SPEC_RULE_OP1, - 1816 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1841 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1866 | SPEC_RULE_OP1, - 1871 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1896 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1921 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 1946, - 1947 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 3486, + 1590 | SPEC_RULE_OP1, + 1595 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1620 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1645 | SPEC_RULE_OP1, + 1650 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1675 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1700 | SPEC_RULE_OP1, + 1705 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1730 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1755 | SPEC_RULE_OP1, + 1760 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1785 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1810 | SPEC_RULE_OP1, + 1815 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1840 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1865 | SPEC_RULE_OP1, + 1870 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1895 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1920 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 1945, + 1946 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 1956, 1957, 1958, 1959, 1960, - 1961, - 1962 | SPEC_RULE_OP2, - 1967, - 1968 | SPEC_RULE_OP1, - 1973 | SPEC_RULE_OP2, - 1978 | SPEC_RULE_OP1, - 1983 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, - 1993 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2018 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2043 | SPEC_RULE_OP1, - 2048 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2073 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, - 2123 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2148 | SPEC_RULE_OP2, - 2153, - 2154 | SPEC_RULE_OP1, - 2159 | SPEC_RULE_OP1, - 2164, - 2165 | SPEC_RULE_OP1, - 2170 | SPEC_RULE_OP1, - 2175 | SPEC_RULE_OP1, + 1961 | SPEC_RULE_OP2, + 1966, + 1967 | SPEC_RULE_OP1, + 1972 | SPEC_RULE_OP2, + 1977 | SPEC_RULE_OP1, + 1982 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 1992 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2017 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2042 | SPEC_RULE_OP1, + 2047 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2072 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG, + 2122 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2147 | SPEC_RULE_OP2, + 2152, + 2153 | SPEC_RULE_OP1, + 2158 | SPEC_RULE_OP1, + 2163, + 2164 | SPEC_RULE_OP1, + 2169 | SPEC_RULE_OP1, + 2174 | SPEC_RULE_OP1, + 2179, 2180, - 2181, - 2182 | SPEC_RULE_OP2, - 2187 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, - 2191 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, - 2195 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, - 2199 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2199 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2224 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2224 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2249 | SPEC_RULE_OP1, - 2254, - 2255 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2280, - 2281 | SPEC_RULE_OP1, + 2181 | SPEC_RULE_OP2, + 2186 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 2190 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 2194 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER, + 2198 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2198 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2223 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2223 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2248 | SPEC_RULE_OP1, + 2253, + 2254 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2279, + 2280 | SPEC_RULE_OP1, + 2285, 2286, 2287, 2288, 2289, 2290, 2291, - 2292, - 2293 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2292 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2317, 2318, 2319, - 2320, - 2321 | SPEC_RULE_OP1, - 2326, - 2327 | SPEC_RULE_ISSET, - 2329 | SPEC_RULE_OP2, - 2334, - 2335 | SPEC_RULE_OP1, - 2340 | SPEC_RULE_OBSERVER, - 2342, - 2343 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2368 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 2320 | SPEC_RULE_OP1, + 2325, + 2326 | SPEC_RULE_ISSET, + 2328 | SPEC_RULE_OP2, + 2333, + 2334 | SPEC_RULE_OP1, + 2339 | SPEC_RULE_OBSERVER, + 2341, + 2342 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2367 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER, + 2377, 2378, 2379, 2380, - 2381, - 2382 | SPEC_RULE_OP1, + 2381 | SPEC_RULE_OP1, + 2386, 2387, - 2388, - 2389 | SPEC_RULE_OP1, - 2394 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2419, - 2420 | SPEC_RULE_OP1, + 2388 | SPEC_RULE_OP1, + 2393 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2418, + 2419 | SPEC_RULE_OP1, + 2424, 2425, 2426, 2427, @@ -67595,82 +67549,81 @@ void zend_vm_init(void) 2429, 2430, 2431, - 2432, - 2433 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2432 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2457, 2458, 2459, - 2460, - 2461 | SPEC_RULE_OP2, - 2466, - 2467 | SPEC_RULE_OP1, - 2472 | SPEC_RULE_OP1, - 2477 | SPEC_RULE_OP1, - 2482 | SPEC_RULE_OP1, - 2487 | SPEC_RULE_OP1, - 2492, - 2493 | SPEC_RULE_OP1, - 2498 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2523 | SPEC_RULE_OP1, - 2528 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 2553 | SPEC_RULE_OP1, - 2558 | SPEC_RULE_OP1, + 2460 | SPEC_RULE_OP2, + 2465, + 2466 | SPEC_RULE_OP1, + 2471 | SPEC_RULE_OP1, + 2476 | SPEC_RULE_OP1, + 2481 | SPEC_RULE_OP1, + 2486 | SPEC_RULE_OP1, + 2491, + 2492 | SPEC_RULE_OP1, + 2497 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2522 | SPEC_RULE_OP1, + 2527 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2552 | SPEC_RULE_OP1, + 2557 | SPEC_RULE_OP1, + 2562, 2563, 2564, 2565, 2566, - 2567, - 2568 | SPEC_RULE_OBSERVER, - 2570 | SPEC_RULE_OBSERVER, - 2572 | SPEC_RULE_OBSERVER, - 2574 | SPEC_RULE_OBSERVER, + 2567 | SPEC_RULE_OBSERVER, + 2569 | SPEC_RULE_OBSERVER, + 2571 | SPEC_RULE_OBSERVER, + 2573 | SPEC_RULE_OBSERVER, + 2575, 2576, - 2577, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, - 3487, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, + 3486, }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -67843,7 +67796,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 = 2586 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2585 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -67851,7 +67804,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 = 2611 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2610 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -67859,7 +67812,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 = 2636 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2635 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -67870,17 +67823,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 = 2661 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2660 | 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 = 2686 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2685 | 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 = 2711 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2710 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -67891,17 +67844,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 = 2736 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2735 | 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 = 2761 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2760 | 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 = 2786 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2785 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -67912,14 +67865,14 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2811 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2810 | 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 = 2886 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2885 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3111 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3110 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -67930,14 +67883,14 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2961 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2960 | 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 = 3036 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3035 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3116 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3115 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -67948,12 +67901,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 = 2811 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2810 | 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 = 2886 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2885 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -67964,12 +67917,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 = 2961 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2960 | 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 = 3036 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3035 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -67977,12 +67930,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 = 3121 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3120 | 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 = 3196 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3195 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -67990,79 +67943,79 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3271 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3270 | 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 = 3346 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3345 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3433 | SPEC_RULE_OP1; + spec = 3432 | SPEC_RULE_OP1; } else if (op1_info == MAY_BE_DOUBLE) { - spec = 3438 | SPEC_RULE_OP1; + spec = 3437 | 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 = 3443 | SPEC_RULE_OP1; + spec = 3442 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3421 | SPEC_RULE_RETVAL; + spec = 3420 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3423 | SPEC_RULE_RETVAL; + spec = 3422 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3425 | SPEC_RULE_RETVAL; + spec = 3424 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3427 | SPEC_RULE_RETVAL; + spec = 3426 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3429; + spec = 3428; } else if (op1_info == MAY_BE_LONG) { - spec = 3430; + spec = 3429; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3431; + spec = 3430; } else if (op1_info == MAY_BE_LONG) { - spec = 3432; + spec = 3431; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2585; + spec = 2584; } break; case ZEND_INIT_FCALL: if (Z_EXTRA_P(RT_CONSTANT(op, op->op2)) != 0) { - spec = 2578; + spec = 2577; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2579; + spec = 2578; } break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3483; + spec = 3482; } break; case ZEND_SEND_VAR_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3478 | SPEC_RULE_OP1; + spec = 3477 | SPEC_RULE_OP1; } break; case ZEND_FE_FETCH_R: if (op->op2_type == IS_CV && (op1_info & (MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 3485 | SPEC_RULE_RETVAL; + spec = 3484 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -68070,22 +68023,22 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3448 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3447 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_SEND_VAL_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3484; + spec = 3483; } break; case ZEND_SEND_VAR: if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3473 | SPEC_RULE_OP1; + spec = 3472 | SPEC_RULE_OP1; } break; case ZEND_COUNT: if ((op1_info & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 2580 | SPEC_RULE_OP1; + spec = 2579 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 99abc0ffb12de..7f3a3cb5de260 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -751,1124 +751,1123 @@ _(1586, ZEND_FE_RESET_R_SPEC_VAR) \ _(1588, ZEND_FE_RESET_R_SPEC_CV) \ _(1589, ZEND_FE_FETCH_R_SPEC_VAR) \ - _(1590, ZEND_EXIT_SPEC) \ - _(1591, ZEND_FETCH_R_SPEC_CONST_UNUSED) \ + _(1590, ZEND_FETCH_R_SPEC_CONST_UNUSED) \ + _(1591, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ _(1592, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ - _(1593, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \ - _(1595, ZEND_FETCH_R_SPEC_CV_UNUSED) \ - _(1596, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \ + _(1594, ZEND_FETCH_R_SPEC_CV_UNUSED) \ + _(1595, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \ + _(1596, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ _(1597, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ - _(1598, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \ - _(1600, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \ - _(1601, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ + _(1599, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \ + _(1600, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ + _(1601, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ _(1602, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1603, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1605, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ - _(1606, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ + _(1604, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ + _(1605, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \ + _(1606, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ _(1607, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1608, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \ - _(1610, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ - _(1616, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \ + _(1609, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \ + _(1615, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \ + _(1616, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ _(1617, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ - _(1618, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \ - _(1620, ZEND_FETCH_DIM_R_SPEC_CV_CV) \ - _(1621, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \ + _(1619, ZEND_FETCH_DIM_R_SPEC_CV_CV) \ + _(1620, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \ + _(1621, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ _(1622, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ - _(1623, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \ - _(1625, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \ - _(1626, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ + _(1624, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \ + _(1625, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ + _(1626, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ _(1627, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1628, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1630, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ - _(1631, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ + _(1629, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ + _(1630, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \ + _(1631, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ _(1632, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1633, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \ - _(1635, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ - _(1636, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \ + _(1634, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \ + _(1635, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \ + _(1636, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ _(1637, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ - _(1638, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \ - _(1640, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \ - _(1641, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \ + _(1639, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \ + _(1640, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \ + _(1641, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ _(1642, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ - _(1643, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \ - _(1645, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \ - _(1646, ZEND_FETCH_W_SPEC_CONST_UNUSED) \ + _(1644, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \ + _(1645, ZEND_FETCH_W_SPEC_CONST_UNUSED) \ + _(1646, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ _(1647, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ - _(1648, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \ - _(1650, ZEND_FETCH_W_SPEC_CV_UNUSED) \ - _(1661, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \ + _(1649, ZEND_FETCH_W_SPEC_CV_UNUSED) \ + _(1660, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \ + _(1661, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ _(1662, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ - _(1663, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \ - _(1664, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED) \ - _(1665, ZEND_FETCH_DIM_W_SPEC_VAR_CV) \ - _(1671, ZEND_FETCH_DIM_W_SPEC_CV_CONST) \ + _(1663, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED) \ + _(1664, ZEND_FETCH_DIM_W_SPEC_VAR_CV) \ + _(1670, ZEND_FETCH_DIM_W_SPEC_CV_CONST) \ + _(1671, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ _(1672, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ - _(1673, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \ - _(1674, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED) \ - _(1675, ZEND_FETCH_DIM_W_SPEC_CV_CV) \ - _(1686, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST) \ + _(1673, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED) \ + _(1674, ZEND_FETCH_DIM_W_SPEC_CV_CV) \ + _(1685, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST) \ + _(1686, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ _(1687, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ - _(1688, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \ - _(1690, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \ - _(1691, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \ + _(1689, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \ + _(1690, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \ + _(1691, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ _(1692, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ - _(1693, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \ - _(1695, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \ - _(1696, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \ + _(1694, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \ + _(1695, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \ + _(1696, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ _(1697, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ - _(1698, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \ - _(1700, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \ - _(1701, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \ + _(1699, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \ + _(1700, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \ + _(1701, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ _(1702, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ - _(1703, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \ - _(1705, ZEND_FETCH_RW_SPEC_CV_UNUSED) \ - _(1716, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \ + _(1704, ZEND_FETCH_RW_SPEC_CV_UNUSED) \ + _(1715, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \ + _(1716, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ _(1717, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ - _(1718, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \ - _(1719, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED) \ - _(1720, ZEND_FETCH_DIM_RW_SPEC_VAR_CV) \ - _(1726, ZEND_FETCH_DIM_RW_SPEC_CV_CONST) \ + _(1718, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED) \ + _(1719, ZEND_FETCH_DIM_RW_SPEC_VAR_CV) \ + _(1725, ZEND_FETCH_DIM_RW_SPEC_CV_CONST) \ + _(1726, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ _(1727, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ - _(1728, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \ - _(1729, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED) \ - _(1730, ZEND_FETCH_DIM_RW_SPEC_CV_CV) \ - _(1741, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST) \ + _(1728, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED) \ + _(1729, ZEND_FETCH_DIM_RW_SPEC_CV_CV) \ + _(1740, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST) \ + _(1741, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ _(1742, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ - _(1743, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \ - _(1745, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \ - _(1746, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \ + _(1744, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \ + _(1745, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \ + _(1746, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ _(1747, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ - _(1748, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \ - _(1750, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \ - _(1751, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \ + _(1749, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \ + _(1750, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \ + _(1751, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ _(1752, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ - _(1753, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \ - _(1755, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \ - _(1756, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \ + _(1754, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \ + _(1755, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \ + _(1756, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ _(1757, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ - _(1758, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \ - _(1760, ZEND_FETCH_IS_SPEC_CV_UNUSED) \ - _(1761, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \ + _(1759, ZEND_FETCH_IS_SPEC_CV_UNUSED) \ + _(1760, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \ + _(1761, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ _(1762, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ - _(1763, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \ - _(1765, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \ - _(1766, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ + _(1764, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \ + _(1765, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ + _(1766, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ _(1767, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1768, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1770, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ - _(1771, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ + _(1769, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ + _(1770, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \ + _(1771, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ _(1772, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1773, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \ - _(1775, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ - _(1781, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \ + _(1774, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \ + _(1780, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \ + _(1781, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ _(1782, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ - _(1783, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \ - _(1785, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \ - _(1786, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \ + _(1784, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \ + _(1785, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \ + _(1786, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ _(1787, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ - _(1788, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \ - _(1790, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \ - _(1791, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ + _(1789, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \ + _(1790, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ + _(1791, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ _(1792, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1793, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1795, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ - _(1796, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ + _(1794, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ + _(1795, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \ + _(1796, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ _(1797, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1798, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \ - _(1800, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ - _(1801, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \ + _(1799, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \ + _(1800, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \ + _(1801, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ _(1802, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ - _(1803, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \ - _(1805, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \ - _(1806, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \ + _(1804, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \ + _(1805, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \ + _(1806, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ _(1807, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ - _(1808, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \ - _(1810, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \ - _(1811, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \ + _(1809, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \ + _(1810, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \ + _(1811, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ _(1812, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ - _(1813, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \ - _(1815, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED) \ - _(1816, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST) \ + _(1814, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED) \ + _(1815, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST) \ + _(1816, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ _(1817, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1818, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1819, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED) \ - _(1820, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV) \ - _(1821, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) \ + _(1818, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED) \ + _(1819, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV) \ + _(1820, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) \ + _(1821, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ _(1822, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1823, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1824, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) \ - _(1825, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) \ - _(1826, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST) \ + _(1823, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) \ + _(1824, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) \ + _(1825, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST) \ + _(1826, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ _(1827, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1828, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1829, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED) \ - _(1830, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV) \ - _(1836, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST) \ + _(1828, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED) \ + _(1829, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV) \ + _(1835, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST) \ + _(1836, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ _(1837, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1838, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1839, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED) \ - _(1840, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV) \ - _(1841, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST) \ + _(1838, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED) \ + _(1839, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV) \ + _(1840, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST) \ + _(1841, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ _(1842, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1843, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \ - _(1845, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV) \ - _(1846, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) \ + _(1844, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV) \ + _(1845, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) \ + _(1846, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ _(1847, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1848, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \ - _(1850, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) \ - _(1851, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST) \ + _(1849, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) \ + _(1850, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST) \ + _(1851, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ _(1852, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1853, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \ - _(1855, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV) \ - _(1856, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1854, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV) \ + _(1855, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST) \ + _(1856, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ _(1857, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ - _(1858, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \ - _(1860, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV) \ - _(1861, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST) \ + _(1859, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV) \ + _(1860, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST) \ + _(1861, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ _(1862, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1863, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \ - _(1865, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \ - _(1866, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \ + _(1864, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \ + _(1865, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \ + _(1866, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ _(1867, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ - _(1868, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \ - _(1870, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \ - _(1881, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \ + _(1869, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \ + _(1880, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \ + _(1881, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ _(1882, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ - _(1883, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \ - _(1885, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \ - _(1891, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \ + _(1884, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \ + _(1890, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \ + _(1891, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ _(1892, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ - _(1893, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \ - _(1895, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \ - _(1906, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \ + _(1894, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \ + _(1905, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \ + _(1906, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ _(1907, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ - _(1908, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \ - _(1910, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \ - _(1911, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \ + _(1909, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \ + _(1910, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \ + _(1911, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ _(1912, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ - _(1913, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \ - _(1915, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \ - _(1916, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \ + _(1914, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \ + _(1915, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \ + _(1916, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ _(1917, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ - _(1918, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \ - _(1920, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \ - _(1921, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \ + _(1919, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \ + _(1920, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \ + _(1921, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ _(1922, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ - _(1923, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \ - _(1925, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \ - _(1926, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1924, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \ + _(1925, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1926, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ _(1927, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1928, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1930, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1931, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1929, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1930, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1931, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ _(1932, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1933, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1935, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1941, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1934, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1940, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \ + _(1941, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ _(1942, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1943, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \ - _(1945, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ - _(1946, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) \ + _(1944, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \ + _(1945, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) \ + _(1946, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ _(1947, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ - _(1948, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \ - _(1953, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED) \ - _(1954, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK) \ - _(1957, ZEND_EXT_STMT_SPEC) \ - _(1958, ZEND_EXT_FCALL_BEGIN_SPEC) \ - _(1959, ZEND_EXT_FCALL_END_SPEC) \ - _(1960, ZEND_EXT_NOP_SPEC) \ - _(1961, ZEND_TICKS_SPEC) \ - _(1962, ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST) \ - _(1965, ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED) \ - _(1967, ZEND_CATCH_SPEC_CONST) \ - _(1968, ZEND_THROW_SPEC_CONST) \ + _(1952, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED) \ + _(1953, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK) \ + _(1956, ZEND_EXT_STMT_SPEC) \ + _(1957, ZEND_EXT_FCALL_BEGIN_SPEC) \ + _(1958, ZEND_EXT_FCALL_END_SPEC) \ + _(1959, ZEND_EXT_NOP_SPEC) \ + _(1960, ZEND_TICKS_SPEC) \ + _(1961, ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST) \ + _(1964, ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED) \ + _(1966, ZEND_CATCH_SPEC_CONST) \ + _(1967, ZEND_THROW_SPEC_CONST) \ + _(1968, ZEND_THROW_SPEC_TMPVAR) \ _(1969, ZEND_THROW_SPEC_TMPVAR) \ - _(1970, ZEND_THROW_SPEC_TMPVAR) \ - _(1972, ZEND_THROW_SPEC_CV) \ - _(1973, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \ + _(1971, ZEND_THROW_SPEC_CV) \ + _(1972, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \ + _(1973, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ _(1974, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ - _(1975, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \ - _(1976, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \ - _(1977, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \ - _(1978, ZEND_CLONE_SPEC_CONST) \ + _(1975, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \ + _(1976, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \ + _(1977, ZEND_CLONE_SPEC_CONST) \ + _(1978, ZEND_CLONE_SPEC_TMPVAR) \ _(1979, ZEND_CLONE_SPEC_TMPVAR) \ - _(1980, ZEND_CLONE_SPEC_TMPVAR) \ - _(1981, ZEND_CLONE_SPEC_UNUSED) \ - _(1982, ZEND_CLONE_SPEC_CV) \ - _(1983, ZEND_RETURN_BY_REF_SPEC_CONST) \ - _(1984, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ - _(1985, ZEND_RETURN_BY_REF_SPEC_TMP) \ - _(1986, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ - _(1987, ZEND_RETURN_BY_REF_SPEC_VAR) \ - _(1988, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ - _(1991, ZEND_RETURN_BY_REF_SPEC_CV) \ - _(1992, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ - _(1993, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) \ + _(1980, ZEND_CLONE_SPEC_UNUSED) \ + _(1981, ZEND_CLONE_SPEC_CV) \ + _(1982, ZEND_RETURN_BY_REF_SPEC_CONST) \ + _(1983, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ + _(1984, ZEND_RETURN_BY_REF_SPEC_TMP) \ + _(1985, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ + _(1986, ZEND_RETURN_BY_REF_SPEC_VAR) \ + _(1987, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ + _(1990, ZEND_RETURN_BY_REF_SPEC_CV) \ + _(1991, ZEND_RETURN_BY_REF_SPEC_OBSERVER) \ + _(1992, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) \ + _(1993, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ _(1994, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(1995, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(1997, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \ - _(1998, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ + _(1996, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \ + _(1997, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ + _(1998, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ _(1999, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(2000, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(2002, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ - _(2003, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ + _(2001, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ + _(2002, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \ + _(2003, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ _(2004, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(2005, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \ - _(2007, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ - _(2008, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \ + _(2006, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \ + _(2007, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \ + _(2008, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ _(2009, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2010, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2012, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \ - _(2013, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \ + _(2011, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \ + _(2012, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \ + _(2013, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ _(2014, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ - _(2015, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \ - _(2017, ZEND_INIT_METHOD_CALL_SPEC_CV_CV) \ - _(2018, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) \ + _(2016, ZEND_INIT_METHOD_CALL_SPEC_CV_CV) \ + _(2017, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) \ + _(2018, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ _(2019, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(2020, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \ - _(2021, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) \ - _(2022, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) \ - _(2028, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) \ + _(2020, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) \ + _(2021, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) \ + _(2027, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) \ + _(2028, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ _(2029, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ - _(2030, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \ - _(2031, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) \ - _(2032, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) \ - _(2033, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) \ + _(2030, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) \ + _(2031, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) \ + _(2032, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) \ + _(2033, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ _(2034, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2035, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \ - _(2036, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) \ - _(2037, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) \ - _(2043, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) \ + _(2035, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) \ + _(2036, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) \ + _(2042, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) \ + _(2043, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ _(2044, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ - _(2045, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \ - _(2047, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED) \ - _(2048, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST) \ + _(2046, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED) \ + _(2047, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST) \ + _(2048, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ _(2049, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ - _(2050, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \ - _(2052, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \ - _(2053, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ + _(2051, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \ + _(2052, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ + _(2053, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ _(2054, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2055, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2057, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ - _(2058, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ + _(2056, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ + _(2057, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \ + _(2058, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ _(2059, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2060, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2062, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ - _(2068, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \ + _(2061, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \ + _(2067, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \ + _(2068, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ _(2069, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ - _(2070, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \ - _(2072, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV) \ + _(2071, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV) \ + _(2072, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ _(2073, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ - _(2074, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \ - _(2079, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED) \ - _(2080, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK) \ + _(2078, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED) \ + _(2079, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK) \ + _(2082, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ _(2083, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ - _(2084, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \ - _(2089, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED) \ - _(2090, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK) \ - _(2133, ZEND_SEND_VAR_SPEC_VAR_CONST) \ - _(2136, ZEND_SEND_VAR_SPEC_VAR_UNUSED) \ - _(2143, ZEND_SEND_VAR_SPEC_CV_CONST) \ - _(2146, ZEND_SEND_VAR_SPEC_CV_UNUSED) \ - _(2148, ZEND_INIT_USER_CALL_SPEC_CONST_CONST) \ + _(2088, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED) \ + _(2089, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK) \ + _(2132, ZEND_SEND_VAR_SPEC_VAR_CONST) \ + _(2135, ZEND_SEND_VAR_SPEC_VAR_UNUSED) \ + _(2142, ZEND_SEND_VAR_SPEC_CV_CONST) \ + _(2145, ZEND_SEND_VAR_SPEC_CV_UNUSED) \ + _(2147, ZEND_INIT_USER_CALL_SPEC_CONST_CONST) \ + _(2148, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ _(2149, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ - _(2150, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \ - _(2152, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \ - _(2153, ZEND_SEND_ARRAY_SPEC) \ - _(2154, ZEND_SEND_USER_SPEC_CONST) \ - _(2155, ZEND_SEND_USER_SPEC_TMP) \ - _(2156, ZEND_SEND_USER_SPEC_VAR) \ - _(2158, ZEND_SEND_USER_SPEC_CV) \ - _(2159, ZEND_STRLEN_SPEC_CONST) \ + _(2151, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \ + _(2152, ZEND_SEND_ARRAY_SPEC) \ + _(2153, ZEND_SEND_USER_SPEC_CONST) \ + _(2154, ZEND_SEND_USER_SPEC_TMP) \ + _(2155, ZEND_SEND_USER_SPEC_VAR) \ + _(2157, ZEND_SEND_USER_SPEC_CV) \ + _(2158, ZEND_STRLEN_SPEC_CONST) \ + _(2159, ZEND_STRLEN_SPEC_TMPVAR) \ _(2160, ZEND_STRLEN_SPEC_TMPVAR) \ - _(2161, ZEND_STRLEN_SPEC_TMPVAR) \ - _(2163, ZEND_STRLEN_SPEC_CV) \ - _(2164, ZEND_DEFINED_SPEC_CONST) \ - _(2165, ZEND_TYPE_CHECK_SPEC_CONST) \ + _(2162, ZEND_STRLEN_SPEC_CV) \ + _(2163, ZEND_DEFINED_SPEC_CONST) \ + _(2164, ZEND_TYPE_CHECK_SPEC_CONST) \ + _(2165, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ _(2166, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ - _(2167, ZEND_TYPE_CHECK_SPEC_TMPVAR) \ - _(2169, ZEND_TYPE_CHECK_SPEC_CV) \ - _(2170, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \ - _(2171, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \ - _(2172, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \ - _(2173, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \ - _(2174, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \ - _(2175, ZEND_FE_RESET_RW_SPEC_CONST) \ - _(2176, ZEND_FE_RESET_RW_SPEC_TMP) \ - _(2177, ZEND_FE_RESET_RW_SPEC_VAR) \ - _(2179, ZEND_FE_RESET_RW_SPEC_CV) \ - _(2180, ZEND_FE_FETCH_RW_SPEC_VAR) \ - _(2181, ZEND_FE_FREE_SPEC_TMPVAR) \ - _(2182, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \ + _(2168, ZEND_TYPE_CHECK_SPEC_CV) \ + _(2169, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \ + _(2170, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \ + _(2171, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \ + _(2172, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \ + _(2173, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \ + _(2174, ZEND_FE_RESET_RW_SPEC_CONST) \ + _(2175, ZEND_FE_RESET_RW_SPEC_TMP) \ + _(2176, ZEND_FE_RESET_RW_SPEC_VAR) \ + _(2178, ZEND_FE_RESET_RW_SPEC_CV) \ + _(2179, ZEND_FE_FETCH_RW_SPEC_VAR) \ + _(2180, ZEND_FE_FREE_SPEC_TMPVAR) \ + _(2181, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \ + _(2182, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ _(2183, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ - _(2184, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \ - _(2186, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \ - _(2187, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \ - _(2188, ZEND_DO_ICALL_SPEC_RETVAL_USED) \ + _(2185, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \ + _(2186, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \ + _(2187, ZEND_DO_ICALL_SPEC_RETVAL_USED) \ + _(2188, ZEND_DO_ICALL_SPEC_OBSERVER) \ _(2189, ZEND_DO_ICALL_SPEC_OBSERVER) \ - _(2190, ZEND_DO_ICALL_SPEC_OBSERVER) \ - _(2191, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \ - _(2192, ZEND_DO_UCALL_SPEC_RETVAL_USED) \ + _(2190, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \ + _(2191, ZEND_DO_UCALL_SPEC_RETVAL_USED) \ + _(2192, ZEND_DO_UCALL_SPEC_OBSERVER) \ _(2193, ZEND_DO_UCALL_SPEC_OBSERVER) \ - _(2194, ZEND_DO_UCALL_SPEC_OBSERVER) \ - _(2195, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \ - _(2196, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \ + _(2194, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \ + _(2195, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \ + _(2196, ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER) \ _(2197, ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER) \ - _(2198, ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER) \ - _(2209, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \ + _(2208, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \ + _(2209, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ _(2210, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2211, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2213, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \ - _(2214, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2212, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \ + _(2213, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2214, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ _(2215, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2216, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2218, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \ - _(2219, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \ + _(2217, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \ + _(2218, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \ + _(2219, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ _(2220, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2221, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2223, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \ - _(2234, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \ + _(2222, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \ + _(2233, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \ + _(2234, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ _(2235, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2236, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \ - _(2238, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \ - _(2239, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2237, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \ + _(2238, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \ + _(2239, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ _(2240, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2241, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2243, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \ - _(2244, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \ + _(2242, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \ + _(2243, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \ + _(2244, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ _(2245, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2246, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \ - _(2248, ZEND_POST_INC_OBJ_SPEC_CV_CV) \ - _(2249, ZEND_ECHO_SPEC_CONST) \ + _(2247, ZEND_POST_INC_OBJ_SPEC_CV_CV) \ + _(2248, ZEND_ECHO_SPEC_CONST) \ + _(2249, ZEND_ECHO_SPEC_TMPVAR) \ _(2250, ZEND_ECHO_SPEC_TMPVAR) \ - _(2251, ZEND_ECHO_SPEC_TMPVAR) \ - _(2253, ZEND_ECHO_SPEC_CV) \ - _(2260, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ - _(2262, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ - _(2263, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ - _(2265, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ - _(2267, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ - _(2268, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ - _(2275, ZEND_INSTANCEOF_SPEC_CV_CONST) \ - _(2277, ZEND_INSTANCEOF_SPEC_CV_VAR) \ - _(2278, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \ - _(2280, ZEND_GENERATOR_CREATE_SPEC) \ - _(2283, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \ - _(2285, ZEND_MAKE_REF_SPEC_CV_UNUSED) \ - _(2286, ZEND_DECLARE_FUNCTION_SPEC) \ - _(2287, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST) \ - _(2288, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ - _(2289, ZEND_DECLARE_CLASS_SPEC_CONST) \ - _(2290, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \ - _(2291, ZEND_DECLARE_ANON_CLASS_SPEC) \ - _(2292, ZEND_ADD_ARRAY_UNPACK_SPEC) \ - _(2293, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ + _(2252, ZEND_ECHO_SPEC_CV) \ + _(2259, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ + _(2261, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ + _(2262, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ + _(2264, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \ + _(2266, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \ + _(2267, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \ + _(2274, ZEND_INSTANCEOF_SPEC_CV_CONST) \ + _(2276, ZEND_INSTANCEOF_SPEC_CV_VAR) \ + _(2277, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \ + _(2279, ZEND_GENERATOR_CREATE_SPEC) \ + _(2282, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \ + _(2284, ZEND_MAKE_REF_SPEC_CV_UNUSED) \ + _(2285, ZEND_DECLARE_FUNCTION_SPEC) \ + _(2286, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST) \ + _(2287, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \ + _(2288, ZEND_DECLARE_CLASS_SPEC_CONST) \ + _(2289, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \ + _(2290, ZEND_DECLARE_ANON_CLASS_SPEC) \ + _(2291, ZEND_ADD_ARRAY_UNPACK_SPEC) \ + _(2292, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \ + _(2293, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ _(2294, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ - _(2295, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \ - _(2297, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ - _(2298, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ + _(2296, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \ + _(2297, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ + _(2298, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ _(2299, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2300, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2302, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ - _(2303, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ + _(2301, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ + _(2302, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \ + _(2303, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ _(2304, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2305, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \ - _(2307, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ - _(2308, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ + _(2306, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \ + _(2307, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \ + _(2308, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ _(2309, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2310, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \ - _(2312, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ - _(2313, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ + _(2311, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \ + _(2312, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \ + _(2313, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ _(2314, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ - _(2315, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \ - _(2317, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ - _(2318, ZEND_HANDLE_EXCEPTION_SPEC) \ - _(2319, ZEND_USER_OPCODE_SPEC) \ - _(2320, ZEND_ASSERT_CHECK_SPEC) \ - _(2321, ZEND_JMP_SET_SPEC_CONST) \ - _(2322, ZEND_JMP_SET_SPEC_TMP) \ - _(2323, ZEND_JMP_SET_SPEC_VAR) \ - _(2325, ZEND_JMP_SET_SPEC_CV) \ - _(2326, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ - _(2327, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ - _(2328, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ - _(2329, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ + _(2316, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \ + _(2317, ZEND_HANDLE_EXCEPTION_SPEC) \ + _(2318, ZEND_USER_OPCODE_SPEC) \ + _(2319, ZEND_ASSERT_CHECK_SPEC) \ + _(2320, ZEND_JMP_SET_SPEC_CONST) \ + _(2321, ZEND_JMP_SET_SPEC_TMP) \ + _(2322, ZEND_JMP_SET_SPEC_VAR) \ + _(2324, ZEND_JMP_SET_SPEC_CV) \ + _(2325, ZEND_UNSET_CV_SPEC_CV_UNUSED) \ + _(2326, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \ + _(2327, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \ + _(2328, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \ + _(2329, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ _(2330, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ - _(2331, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \ - _(2333, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ - _(2334, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ + _(2332, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \ + _(2333, ZEND_SEPARATE_SPEC_VAR_UNUSED) \ + _(2335, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ _(2336, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ - _(2337, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \ - _(2338, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ - _(2339, ZEND_FETCH_CLASS_NAME_SPEC_CV) \ - _(2340, ZEND_CALL_TRAMPOLINE_SPEC) \ - _(2341, ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER) \ - _(2342, ZEND_DISCARD_EXCEPTION_SPEC) \ - _(2343, ZEND_YIELD_SPEC_CONST_CONST) \ + _(2337, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \ + _(2338, ZEND_FETCH_CLASS_NAME_SPEC_CV) \ + _(2339, ZEND_CALL_TRAMPOLINE_SPEC) \ + _(2340, ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER) \ + _(2341, ZEND_DISCARD_EXCEPTION_SPEC) \ + _(2342, ZEND_YIELD_SPEC_CONST_CONST) \ + _(2343, ZEND_YIELD_SPEC_CONST_TMPVAR) \ _(2344, ZEND_YIELD_SPEC_CONST_TMPVAR) \ - _(2345, ZEND_YIELD_SPEC_CONST_TMPVAR) \ - _(2346, ZEND_YIELD_SPEC_CONST_UNUSED) \ - _(2347, ZEND_YIELD_SPEC_CONST_CV) \ - _(2348, ZEND_YIELD_SPEC_TMP_CONST) \ + _(2345, ZEND_YIELD_SPEC_CONST_UNUSED) \ + _(2346, ZEND_YIELD_SPEC_CONST_CV) \ + _(2347, ZEND_YIELD_SPEC_TMP_CONST) \ + _(2348, ZEND_YIELD_SPEC_TMP_TMPVAR) \ _(2349, ZEND_YIELD_SPEC_TMP_TMPVAR) \ - _(2350, ZEND_YIELD_SPEC_TMP_TMPVAR) \ - _(2351, ZEND_YIELD_SPEC_TMP_UNUSED) \ - _(2352, ZEND_YIELD_SPEC_TMP_CV) \ - _(2353, ZEND_YIELD_SPEC_VAR_CONST) \ + _(2350, ZEND_YIELD_SPEC_TMP_UNUSED) \ + _(2351, ZEND_YIELD_SPEC_TMP_CV) \ + _(2352, ZEND_YIELD_SPEC_VAR_CONST) \ + _(2353, ZEND_YIELD_SPEC_VAR_TMPVAR) \ _(2354, ZEND_YIELD_SPEC_VAR_TMPVAR) \ - _(2355, ZEND_YIELD_SPEC_VAR_TMPVAR) \ - _(2356, ZEND_YIELD_SPEC_VAR_UNUSED) \ - _(2357, ZEND_YIELD_SPEC_VAR_CV) \ - _(2358, ZEND_YIELD_SPEC_UNUSED_CONST) \ + _(2355, ZEND_YIELD_SPEC_VAR_UNUSED) \ + _(2356, ZEND_YIELD_SPEC_VAR_CV) \ + _(2357, ZEND_YIELD_SPEC_UNUSED_CONST) \ + _(2358, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ _(2359, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ - _(2360, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \ - _(2361, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ - _(2362, ZEND_YIELD_SPEC_UNUSED_CV) \ - _(2363, ZEND_YIELD_SPEC_CV_CONST) \ + _(2360, ZEND_YIELD_SPEC_UNUSED_UNUSED) \ + _(2361, ZEND_YIELD_SPEC_UNUSED_CV) \ + _(2362, ZEND_YIELD_SPEC_CV_CONST) \ + _(2363, ZEND_YIELD_SPEC_CV_TMPVAR) \ _(2364, ZEND_YIELD_SPEC_CV_TMPVAR) \ - _(2365, ZEND_YIELD_SPEC_CV_TMPVAR) \ - _(2366, ZEND_YIELD_SPEC_CV_UNUSED) \ - _(2367, ZEND_YIELD_SPEC_CV_CV) \ - _(2368, ZEND_GENERATOR_RETURN_SPEC_CONST) \ - _(2369, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ - _(2370, ZEND_GENERATOR_RETURN_SPEC_TMP) \ - _(2371, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ - _(2372, ZEND_GENERATOR_RETURN_SPEC_VAR) \ - _(2373, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ - _(2376, ZEND_GENERATOR_RETURN_SPEC_CV) \ - _(2377, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ - _(2378, ZEND_FAST_CALL_SPEC) \ - _(2379, ZEND_FAST_RET_SPEC) \ - _(2380, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ - _(2381, ZEND_SEND_UNPACK_SPEC) \ - _(2382, ZEND_YIELD_FROM_SPEC_CONST) \ + _(2365, ZEND_YIELD_SPEC_CV_UNUSED) \ + _(2366, ZEND_YIELD_SPEC_CV_CV) \ + _(2367, ZEND_GENERATOR_RETURN_SPEC_CONST) \ + _(2368, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ + _(2369, ZEND_GENERATOR_RETURN_SPEC_TMP) \ + _(2370, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ + _(2371, ZEND_GENERATOR_RETURN_SPEC_VAR) \ + _(2372, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ + _(2375, ZEND_GENERATOR_RETURN_SPEC_CV) \ + _(2376, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \ + _(2377, ZEND_FAST_CALL_SPEC) \ + _(2378, ZEND_FAST_RET_SPEC) \ + _(2379, ZEND_RECV_VARIADIC_SPEC_UNUSED) \ + _(2380, ZEND_SEND_UNPACK_SPEC) \ + _(2381, ZEND_YIELD_FROM_SPEC_CONST) \ + _(2382, ZEND_YIELD_FROM_SPEC_TMPVAR) \ _(2383, ZEND_YIELD_FROM_SPEC_TMPVAR) \ - _(2384, ZEND_YIELD_FROM_SPEC_TMPVAR) \ - _(2386, ZEND_YIELD_FROM_SPEC_CV) \ - _(2387, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ - _(2388, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ - _(2389, ZEND_COALESCE_SPEC_CONST) \ - _(2390, ZEND_COALESCE_SPEC_TMP) \ - _(2391, ZEND_COALESCE_SPEC_VAR) \ - _(2393, ZEND_COALESCE_SPEC_CV) \ - _(2394, ZEND_SPACESHIP_SPEC_CONST_CONST) \ + _(2385, ZEND_YIELD_FROM_SPEC_CV) \ + _(2386, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \ + _(2387, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \ + _(2388, ZEND_COALESCE_SPEC_CONST) \ + _(2389, ZEND_COALESCE_SPEC_TMP) \ + _(2390, ZEND_COALESCE_SPEC_VAR) \ + _(2392, ZEND_COALESCE_SPEC_CV) \ + _(2393, ZEND_SPACESHIP_SPEC_CONST_CONST) \ + _(2394, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ _(2395, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ - _(2396, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \ - _(2398, ZEND_SPACESHIP_SPEC_CONST_CV) \ - _(2399, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(2397, ZEND_SPACESHIP_SPEC_CONST_CV) \ + _(2398, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(2399, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ _(2400, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2401, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2403, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(2404, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(2402, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(2403, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \ + _(2404, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ _(2405, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2406, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \ - _(2408, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ - _(2414, ZEND_SPACESHIP_SPEC_CV_CONST) \ + _(2407, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \ + _(2413, ZEND_SPACESHIP_SPEC_CV_CONST) \ + _(2414, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ _(2415, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ - _(2416, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \ - _(2418, ZEND_SPACESHIP_SPEC_CV_CV) \ - _(2419, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ - _(2420, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ - _(2423, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ - _(2425, ZEND_FETCH_STATIC_PROP_R_SPEC) \ - _(2426, ZEND_FETCH_STATIC_PROP_W_SPEC) \ - _(2427, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ - _(2428, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ - _(2429, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ - _(2430, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ - _(2431, ZEND_UNSET_STATIC_PROP_SPEC) \ - _(2432, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ - _(2433, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ + _(2417, ZEND_SPACESHIP_SPEC_CV_CV) \ + _(2418, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \ + _(2419, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \ + _(2422, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \ + _(2424, ZEND_FETCH_STATIC_PROP_R_SPEC) \ + _(2425, ZEND_FETCH_STATIC_PROP_W_SPEC) \ + _(2426, ZEND_FETCH_STATIC_PROP_RW_SPEC) \ + _(2427, ZEND_FETCH_STATIC_PROP_IS_SPEC) \ + _(2428, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \ + _(2429, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \ + _(2430, ZEND_UNSET_STATIC_PROP_SPEC) \ + _(2431, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \ + _(2432, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \ + _(2433, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ _(2434, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ - _(2435, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ - _(2437, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ - _(2443, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ + _(2436, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_TMPVARCV) \ + _(2442, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \ + _(2443, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ _(2444, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ - _(2445, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ - _(2447, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ - _(2448, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ + _(2446, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) \ + _(2447, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \ + _(2448, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ _(2449, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ - _(2450, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ - _(2452, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ - _(2458, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ - _(2459, ZEND_BIND_STATIC_SPEC_CV) \ - _(2460, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ - _(2461, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \ - _(2464, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \ - _(2466, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ - _(2467, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ + _(2451, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) \ + _(2457, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \ + _(2458, ZEND_BIND_STATIC_SPEC_CV) \ + _(2459, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \ + _(2460, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \ + _(2463, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \ + _(2465, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \ + _(2466, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \ + _(2467, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ _(2468, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2469, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2471, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ - _(2472, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ + _(2470, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \ + _(2471, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \ + _(2472, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ _(2473, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2474, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2476, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ - _(2477, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ - _(2478, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ - _(2479, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ - _(2481, ZEND_IN_ARRAY_SPEC_CV_CONST) \ - _(2482, ZEND_COUNT_SPEC_CONST_UNUSED) \ + _(2475, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \ + _(2476, ZEND_IN_ARRAY_SPEC_CONST_CONST) \ + _(2477, ZEND_IN_ARRAY_SPEC_TMP_CONST) \ + _(2478, ZEND_IN_ARRAY_SPEC_VAR_CONST) \ + _(2480, ZEND_IN_ARRAY_SPEC_CV_CONST) \ + _(2481, ZEND_COUNT_SPEC_CONST_UNUSED) \ + _(2482, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ _(2483, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ - _(2484, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \ - _(2486, ZEND_COUNT_SPEC_CV_UNUSED) \ - _(2487, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ + _(2485, ZEND_COUNT_SPEC_CV_UNUSED) \ + _(2486, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \ + _(2487, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ _(2488, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ - _(2489, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \ - _(2490, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ - _(2491, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ - _(2492, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ - _(2493, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ - _(2494, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ - _(2495, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ - _(2497, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ - _(2498, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ + _(2489, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \ + _(2490, ZEND_GET_CLASS_SPEC_CV_UNUSED) \ + _(2491, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \ + _(2492, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \ + _(2493, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \ + _(2494, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \ + _(2496, ZEND_GET_TYPE_SPEC_CV_UNUSED) \ + _(2497, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \ + _(2498, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ _(2499, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ - _(2500, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \ - _(2502, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ - _(2503, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ + _(2501, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \ + _(2502, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ + _(2503, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ _(2504, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2505, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2507, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(2508, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ + _(2506, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(2507, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \ + _(2508, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ _(2509, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2510, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \ - _(2512, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ - _(2518, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ + _(2511, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \ + _(2517, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \ + _(2518, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ _(2519, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ - _(2520, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ - _(2522, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ - _(2523, ZEND_MATCH_SPEC_CONST_CONST) \ + _(2521, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ + _(2522, ZEND_MATCH_SPEC_CONST_CONST) \ + _(2523, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ _(2524, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2525, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2527, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ - _(2533, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ - _(2534, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ - _(2535, ZEND_CASE_STRICT_SPEC_TMP_VAR) \ - _(2537, ZEND_CASE_STRICT_SPEC_TMP_CV) \ - _(2538, ZEND_CASE_STRICT_SPEC_VAR_CONST) \ - _(2539, ZEND_CASE_STRICT_SPEC_VAR_TMP) \ - _(2540, ZEND_CASE_STRICT_SPEC_VAR_VAR) \ - _(2542, ZEND_CASE_STRICT_SPEC_VAR_CV) \ - _(2553, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ + _(2526, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2532, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ + _(2533, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ + _(2534, ZEND_CASE_STRICT_SPEC_TMP_VAR) \ + _(2536, ZEND_CASE_STRICT_SPEC_TMP_CV) \ + _(2537, ZEND_CASE_STRICT_SPEC_VAR_CONST) \ + _(2538, ZEND_CASE_STRICT_SPEC_VAR_TMP) \ + _(2539, ZEND_CASE_STRICT_SPEC_VAR_VAR) \ + _(2541, ZEND_CASE_STRICT_SPEC_VAR_CV) \ + _(2552, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ + _(2553, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ _(2554, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2555, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2557, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ - _(2558, ZEND_JMP_NULL_SPEC_CONST) \ - _(2559, ZEND_JMP_NULL_SPEC_TMP) \ - _(2560, ZEND_JMP_NULL_SPEC_VAR) \ - _(2562, ZEND_JMP_NULL_SPEC_CV) \ - _(2563, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ - _(2564, ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED) \ - _(2565, ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED) \ - _(2566, ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED) \ - _(2567, ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV) \ - _(2568, ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED) \ - _(2569, ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER) \ - _(2570, ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED) \ - _(2571, ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER) \ - _(2572, ZEND_FRAMELESS_ICALL_2_SPEC) \ - _(2573, ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER) \ - _(2574, ZEND_FRAMELESS_ICALL_3_SPEC) \ - _(2575, ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER) \ - _(2576, ZEND_JMP_FRAMELESS_SPEC_CONST) \ - _(2577, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED) \ - _(2578, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \ - _(2579, ZEND_RECV_NOTYPE_SPEC) \ + _(2556, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2557, ZEND_JMP_NULL_SPEC_CONST) \ + _(2558, ZEND_JMP_NULL_SPEC_TMP) \ + _(2559, ZEND_JMP_NULL_SPEC_VAR) \ + _(2561, ZEND_JMP_NULL_SPEC_CV) \ + _(2562, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \ + _(2563, ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED) \ + _(2564, ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED) \ + _(2565, ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED) \ + _(2566, ZEND_BIND_INIT_STATIC_OR_JMP_SPEC_CV) \ + _(2567, ZEND_FRAMELESS_ICALL_0_SPEC_UNUSED_UNUSED) \ + _(2568, ZEND_FRAMELESS_ICALL_0_SPEC_OBSERVER) \ + _(2569, ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED) \ + _(2570, ZEND_FRAMELESS_ICALL_1_SPEC_OBSERVER) \ + _(2571, ZEND_FRAMELESS_ICALL_2_SPEC) \ + _(2572, ZEND_FRAMELESS_ICALL_2_SPEC_OBSERVER) \ + _(2573, ZEND_FRAMELESS_ICALL_3_SPEC) \ + _(2574, ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER) \ + _(2575, ZEND_JMP_FRAMELESS_SPEC_CONST) \ + _(2576, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED) \ + _(2577, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \ + _(2578, ZEND_RECV_NOTYPE_SPEC) \ + _(2580, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \ _(2581, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \ - _(2582, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \ - _(2584, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \ - _(2585, ZEND_JMP_FORWARD_SPEC) \ - _(2591, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2583, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \ + _(2584, ZEND_JMP_FORWARD_SPEC) \ + _(2590, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2591, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2592, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2593, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2595, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2596, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2594, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2595, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2596, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2597, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2598, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2600, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2606, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2599, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2605, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2606, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2607, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2608, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2610, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2616, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2609, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2615, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2616, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2617, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2618, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2620, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2621, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2619, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2620, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2621, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2622, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2623, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2625, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2631, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2624, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2630, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2631, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2632, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2633, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2635, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2641, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2634, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2640, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2641, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2642, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2643, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2645, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2646, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2644, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2645, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2646, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2647, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2648, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2650, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2656, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2649, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2655, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2656, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2657, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2658, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2660, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2659, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2661, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ _(2662, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2663, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2665, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2666, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2664, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2665, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2666, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2667, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2668, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2670, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2671, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2669, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2670, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2671, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2672, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2673, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2675, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2681, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2674, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2680, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2681, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2682, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2683, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2685, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2684, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2686, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ _(2687, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2688, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2690, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2691, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2689, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2690, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2691, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2692, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2693, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2695, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2696, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2694, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2695, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2696, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2697, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2698, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2700, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2706, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2699, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2705, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2706, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2707, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2708, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2710, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2709, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2711, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ _(2712, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2713, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2715, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2716, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2714, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2715, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2716, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2717, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2718, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2720, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2721, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2719, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2720, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2721, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2722, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2723, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2725, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2731, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2724, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2730, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2731, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2732, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2733, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2735, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2741, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2734, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2740, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2741, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2742, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2743, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2745, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2746, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2744, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2745, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2746, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2747, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2748, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2750, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2756, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2749, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2755, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2756, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2757, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2758, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2760, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2766, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2759, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2765, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2766, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2767, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2768, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2770, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2771, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2769, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2770, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2771, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2772, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2773, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2775, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2781, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2774, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2780, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2781, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2782, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2783, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2785, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2791, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2784, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2790, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2791, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2792, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2793, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2795, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2796, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2794, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2795, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2796, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2797, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2798, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2800, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2806, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2799, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2805, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2806, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2807, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2808, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2810, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2826, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2827, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2828, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2829, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2830, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2831, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2832, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2845, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2849, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2853, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2854, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2855, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2871, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2872, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2873, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2874, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2875, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2876, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2877, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2878, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2879, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2883, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2884, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2885, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2901, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2902, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2903, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2904, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2905, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2906, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2907, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2920, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2924, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2928, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2929, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2930, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2946, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2947, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2948, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2949, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2950, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2951, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2952, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2953, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2954, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2958, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2959, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2960, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2976, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2977, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2978, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2979, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2980, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2981, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2982, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2999, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3003, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3004, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3005, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3021, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3022, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3023, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3024, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3025, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3026, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3027, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3028, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3029, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3033, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3034, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3035, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3051, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3052, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3053, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3054, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3055, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3056, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3057, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3074, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3078, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3079, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3080, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3096, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3097, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3098, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3099, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3100, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3101, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3102, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3103, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3104, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3108, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3109, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3110, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3111, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3115, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3116, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3120, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3124, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3125, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3126, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3127, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3128, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3129, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3133, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3134, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3135, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3136, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3137, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3138, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3139, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3140, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3141, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3142, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3152, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3153, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3154, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3158, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3159, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3163, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3164, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3165, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3181, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3182, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3183, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3184, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3185, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3186, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3187, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3188, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3189, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3193, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3194, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3195, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3199, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3200, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3201, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3202, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3203, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3204, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3208, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3209, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3210, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3211, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3212, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3213, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3214, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3217, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3233, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3234, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3238, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3239, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3240, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3256, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3257, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3258, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3259, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3260, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3261, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3262, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3263, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3264, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3268, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3269, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3270, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3277, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3278, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3279, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3283, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3284, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3285, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3286, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3287, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3288, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3289, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3308, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3309, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3313, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3314, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3315, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3331, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3332, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3333, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3334, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3335, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3336, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3337, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3338, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3339, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3343, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3344, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3345, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3352, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3353, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3354, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3358, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3359, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3360, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3361, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3362, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3363, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3364, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3383, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3384, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3388, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3389, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3390, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3406, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3407, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3408, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3409, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3410, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3411, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3412, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3413, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3414, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3418, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3419, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3420, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3421, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3422, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3423, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3424, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3425, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3426, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3427, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3428, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3429, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3430, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3431, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3432, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3433, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(2809, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2825, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2826, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2827, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2828, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2829, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2830, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2831, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2832, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2845, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2852, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2853, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2854, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2870, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2871, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2872, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2873, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2874, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2875, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2876, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2877, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2878, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2882, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2883, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2884, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2900, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2901, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2902, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2903, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2904, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2905, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2906, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2907, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2920, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2927, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2928, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2929, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2945, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2946, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2947, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2948, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2949, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2950, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2951, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2952, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2953, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2957, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2958, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2959, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2975, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2976, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2977, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2978, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2979, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2980, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2981, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2982, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3002, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3003, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3004, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3020, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3021, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3022, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3023, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3024, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3025, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3026, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3027, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3028, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3032, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3033, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3034, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3050, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3051, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3052, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3053, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3054, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3055, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3056, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3057, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3077, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3078, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3079, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3095, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3096, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3097, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3098, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3099, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3100, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3101, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3102, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3103, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3107, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3108, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3109, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3110, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3114, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3115, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3119, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3123, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3124, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3125, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3126, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3127, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3128, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3132, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3133, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3134, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3135, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3136, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3137, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3138, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3139, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3140, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3141, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3142, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3152, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3153, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3154, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3158, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3162, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3163, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3164, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3180, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3181, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3182, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3183, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3184, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3185, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3186, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3187, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3188, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3192, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3193, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3194, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3198, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3199, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3200, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3201, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3202, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3203, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3207, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3208, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3209, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3210, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3211, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3212, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3213, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3214, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3217, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3233, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3237, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3238, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3239, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3255, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3256, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3257, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3258, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3259, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3260, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3261, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3262, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3263, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3267, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3268, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3269, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3273, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3277, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3278, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3282, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3283, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3284, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3285, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3286, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3287, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3288, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3289, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3308, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3312, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3313, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3314, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3330, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3331, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3332, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3333, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3334, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3335, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3336, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3337, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3338, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3342, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3343, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3344, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3348, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3352, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3353, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3357, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3358, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3359, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3360, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3361, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3362, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3363, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3364, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3383, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3387, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3388, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3389, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3405, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3406, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3407, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3408, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3409, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3410, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3411, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3412, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3413, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3417, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3418, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3419, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3420, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3421, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3422, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3423, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3424, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3425, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3426, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3427, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3428, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3429, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3430, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3431, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3432, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3433, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ _(3434, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3435, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3437, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3438, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3436, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3437, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3438, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ _(3439, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3440, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3442, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3443, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3441, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3442, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3443, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ _(3444, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3445, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3447, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3446, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3448, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ _(3449, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3450, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3452, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3453, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3451, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3452, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3453, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ _(3454, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3455, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3457, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3458, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3456, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3457, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3458, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ _(3459, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3460, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3462, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3468, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3461, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3467, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3468, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ _(3469, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3470, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3472, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3475, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3477, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3480, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ - _(3482, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ - _(3483, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3484, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3485, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3486, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3486+1, ZEND_NULL) + _(3471, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3474, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3476, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3479, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ + _(3481, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ + _(3482, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3483, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3484, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3485, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3485+1, ZEND_NULL) diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index d29fc069255db..202dfd3f734f3 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -102,7 +102,7 @@ static const char *zend_vm_opcodes_names[210] = { "ZEND_UNSET_OBJ", "ZEND_FE_RESET_R", "ZEND_FE_FETCH_R", - "ZEND_EXIT", + NULL, "ZEND_FETCH_R", "ZEND_FETCH_DIM_R", "ZEND_FETCH_OBJ_R", diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h index 2f59a5c874462..d472b5b9660f5 100644 --- a/Zend/zend_vm_opcodes.h +++ b/Zend/zend_vm_opcodes.h @@ -161,7 +161,6 @@ END_EXTERN_C() #define ZEND_UNSET_OBJ 76 #define ZEND_FE_RESET_R 77 #define ZEND_FE_FETCH_R 78 -#define ZEND_EXIT 79 #define ZEND_FETCH_R 80 #define ZEND_FETCH_DIM_R 81 #define ZEND_FETCH_OBJ_R 82 diff --git a/build/gen_stub.php b/build/gen_stub.php index 2898002094040..1d92ddd46b9ee 100755 --- a/build/gen_stub.php +++ b/build/gen_stub.php @@ -83,9 +83,15 @@ function processStubFile(string $stubFile, Context $context, bool $includeOnly = } } + /* Because exit() and die() are proper token/keywords we need to hack-around */ + $hasSpecialExitAsFunctionHandling = str_ends_with($stubFile, 'zend_builtin_functions.stub.php'); if (!$fileInfo = $context->parsedFiles[$stubFile] ?? null) { initPhpParser(); - $fileInfo = parseStubFile($stubCode ?? file_get_contents($stubFile)); + $stubContent = $stubCode ?? file_get_contents($stubFile); + if ($hasSpecialExitAsFunctionHandling) { + $stubContent = str_replace(['exit', 'die'], ['exit_dummy', 'die_dummy'], $stubContent); + } + $fileInfo = parseStubFile($stubContent); $context->parsedFiles[$stubFile] = $fileInfo; foreach ($fileInfo->dependencies as $dependency) { @@ -118,6 +124,9 @@ function processStubFile(string $stubFile, Context $context, bool $includeOnly = $context->allConstInfos, $stubHash ); + if ($hasSpecialExitAsFunctionHandling) { + $arginfoCode = str_replace(['exit_dummy', 'die_dummy'], ['exit', 'die'], $arginfoCode); + } if (($context->forceRegeneration || $stubHash !== $oldStubHash) && file_put_contents($arginfoFile, $arginfoCode)) { echo "Saved $arginfoFile\n"; } diff --git a/ext/hash/hash_sha_ni.c b/ext/hash/hash_sha_ni.c index 3c98786c73fd2..92a2235e28415 100644 --- a/ext/hash/hash_sha_ni.c +++ b/ext/hash/hash_sha_ni.c @@ -27,7 +27,7 @@ #include "php_hash.h" #include "php_hash_sha.h" -#if (defined(__i386__) || defined(__x86_64__)) && defined(HAVE_IMMINTRIN_H) +#if defined(PHP_HASH_INTRIN_SHA_NATIVE) || defined(PHP_HASH_INTRIN_SHA_RESOLVER) # include diff --git a/ext/hash/php_hash_sha.h b/ext/hash/php_hash_sha.h index d5282026b96a6..7336a5ba0aa40 100644 --- a/ext/hash/php_hash_sha.h +++ b/ext/hash/php_hash_sha.h @@ -62,7 +62,9 @@ void SHA256_Transform_sse2(uint32_t state[PHP_STATIC_RESTRICT 8], const uint8_t # elif defined(HAVE_FUNC_ATTRIBUTE_TARGET) # define PHP_HASH_INTRIN_SHA_RESOLVER 1 # endif +#endif +#if defined(PHP_HASH_INTRIN_SHA_NATIVE) || defined(PHP_HASH_INTRIN_SHA_RESOLVER) void SHA256_Transform_shani(uint32_t state[PHP_STATIC_RESTRICT 8], const uint8_t block[PHP_STATIC_RESTRICT 64]); #endif diff --git a/ext/mysqlnd/config.w32 b/ext/mysqlnd/config.w32 index fbe122ab5d36a..9fb58ed50ddf7 100644 --- a/ext/mysqlnd/config.w32 +++ b/ext/mysqlnd/config.w32 @@ -38,6 +38,7 @@ if (PHP_MYSQLND != "no") { AC_DEFINE("MYSQLND_SSL_SUPPORTED", 1, "Define to 1 if mysqlnd core SSL is enabled."); if (CHECK_LIB("crypt32.lib", "mysqlnd")) { AC_DEFINE("MYSQLND_HAVE_SSL", 1, "Define to 1 if mysqlnd extended SSL is enabled through OpenSSL."); + ADD_EXTENSION_DEP('mysqlnd', 'hash'); } } PHP_INSTALL_HEADERS("", "ext/mysqlnd"); diff --git a/ext/mysqlnd/config9.m4 b/ext/mysqlnd/config9.m4 index af242f46d7e2f..1b1d576d440c8 100644 --- a/ext/mysqlnd/config9.m4 +++ b/ext/mysqlnd/config9.m4 @@ -36,11 +36,6 @@ if test "$PHP_MYSQLND" != "no" || test "$PHP_MYSQLND_ENABLED" = "yes"; then AC_DEFINE([MYSQLND_SSL_SUPPORTED], [1], [Define to 1 if mysqlnd core SSL is enabled.]) - AS_VAR_IF([PHP_MYSQLND_SSL], [no],, - [PHP_SETUP_OPENSSL([MYSQLND_SHARED_LIBADD], - [AC_DEFINE([MYSQLND_HAVE_SSL], [1], - [Define to 1 if mysqlnd extended SSL is enabled through OpenSSL.])])]) - PHP_NEW_EXTENSION([mysqlnd], m4_normalize([ mysqlnd_alloc.c mysqlnd_auth.c @@ -68,6 +63,13 @@ if test "$PHP_MYSQLND" != "no" || test "$PHP_MYSQLND_ENABLED" = "yes"; then [$ext_shared],, [-DZEND_ENABLE_STATIC_TSRMLS_CACHE=1]) + AS_VAR_IF([PHP_MYSQLND_SSL], [no],, + [PHP_SETUP_OPENSSL([MYSQLND_SHARED_LIBADD], [ + AC_DEFINE([MYSQLND_HAVE_SSL], [1], + [Define to 1 if mysqlnd extended SSL is enabled through OpenSSL.]) + PHP_ADD_EXTENSION_DEP(mysqlnd, hash) + ])]) + PHP_INSTALL_HEADERS([ext/mysqlnd/]) PHP_SUBST([MYSQLND_SHARED_LIBADD]) fi diff --git a/ext/opcache/jit/zend_jit.c b/ext/opcache/jit/zend_jit.c index 17333fc0d5067..379a5122217d1 100644 --- a/ext/opcache/jit/zend_jit.c +++ b/ext/opcache/jit/zend_jit.c @@ -2557,7 +2557,6 @@ static int zend_jit(const zend_op_array *op_array, zend_ssa *ssa, const zend_op case ZEND_GENERATOR_RETURN: case ZEND_RETURN_BY_REF: case ZEND_RETURN: - case ZEND_EXIT: case ZEND_MATCH_ERROR: /* switch through trampoline */ case ZEND_YIELD: @@ -3470,7 +3469,6 @@ ZEND_EXT_API int zend_jit_check_support(void) /* JIT has no effect on these opcodes */ case ZEND_BEGIN_SILENCE: case ZEND_END_SILENCE: - case ZEND_EXIT: break; default: if (zend_get_user_opcode_handler(i) != NULL) { diff --git a/ext/opcache/jit/zend_jit_ir.c b/ext/opcache/jit/zend_jit_ir.c index 174b07ac10c1d..bb0caf477e511 100644 --- a/ext/opcache/jit/zend_jit_ir.c +++ b/ext/opcache/jit/zend_jit_ir.c @@ -16450,8 +16450,7 @@ static int zend_jit_trace_handler(zend_jit_ctx *jit, const zend_op_array *op_arr } else { ir_GUARD(ir_GE(ref, ir_CONST_I32(0)), jit_STUB_ADDR(jit, jit_stub_trace_halt)); } - } else if (opline->opcode == ZEND_EXIT || - opline->opcode == ZEND_GENERATOR_RETURN || + } else if (opline->opcode == ZEND_GENERATOR_RETURN || opline->opcode == ZEND_YIELD || opline->opcode == ZEND_YIELD_FROM) { ir_IJMP(jit_STUB_ADDR(jit, jit_stub_trace_halt)); diff --git a/ext/opcache/jit/zend_jit_trace.c b/ext/opcache/jit/zend_jit_trace.c index de2481fb8d2bc..c7cd330970dff 100644 --- a/ext/opcache/jit/zend_jit_trace.c +++ b/ext/opcache/jit/zend_jit_trace.c @@ -314,7 +314,6 @@ static int zend_jit_trace_may_exit(const zend_op_array *op_array, const zend_op case ZEND_FAST_RET: case ZEND_GENERATOR_CREATE: case ZEND_GENERATOR_RETURN: - case ZEND_EXIT: case ZEND_YIELD: case ZEND_YIELD_FROM: case ZEND_INCLUDE_OR_EVAL: diff --git a/ext/opcache/tests/jit/ignored_opcodes.phpt b/ext/opcache/tests/jit/ignored_opcodes.phpt index 761a0b699a73a..eac4c237a9c09 100644 --- a/ext/opcache/tests/jit/ignored_opcodes.phpt +++ b/ext/opcache/tests/jit/ignored_opcodes.phpt @@ -9,7 +9,7 @@ opcache.jit=function zend_test.observer.enabled=1 zend_test.observer.show_output=1 zend_test.observer.observe_all=1 -zend_test.observer.show_opcode_in_user_handler=ZEND_EXIT, ZEND_BEGIN_SILENCE, ZEND_END_SILENCE +zend_test.observer.show_opcode_in_user_handler=ZEND_BEGIN_SILENCE, ZEND_END_SILENCE --EXTENSIONS-- opcache zend_test @@ -27,6 +27,9 @@ exit(@test()); - + + + + diff --git a/ext/random/config.m4 b/ext/random/config.m4 index 5c4c2b8bda3ae..ff43b856acf00 100644 --- a/ext/random/config.m4 +++ b/ext/random/config.m4 @@ -12,6 +12,11 @@ AC_CHECK_HEADERS([CommonCrypto/CommonRandom.h],,, [dnl #include ]) +dnl +dnl Mostly for non Linux systems +dnl +AC_CHECK_FUNCS([getrandom]) + dnl dnl Setup extension dnl diff --git a/ext/random/csprng.c b/ext/random/csprng.c index 05fc912317e6a..8b38985c6ac67 100644 --- a/ext/random/csprng.c +++ b/ext/random/csprng.c @@ -48,7 +48,7 @@ #ifdef HAVE_SYS_PARAM_H # include # if (defined(__FreeBSD__) && __FreeBSD_version > 1200000) || (defined(__DragonFly__) && __DragonFly_version >= 500700) || \ - defined(__sun) || (defined(__NetBSD__) && __NetBSD_Version__ >= 1000000000) || defined(__midipix__) + (defined(__sun) && defined(HAVE_GETRANDOM)) || (defined(__NetBSD__) && __NetBSD_Version__ >= 1000000000) || defined(__midipix__) # include # endif #endif @@ -100,7 +100,7 @@ ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_random_bytes_ex(void *bytes, size_ #else size_t read_bytes = 0; # if (defined(__linux__) && defined(SYS_getrandom)) || (defined(__FreeBSD__) && __FreeBSD_version >= 1200000) || (defined(__DragonFly__) && __DragonFly_version >= 500700) || \ - defined(__sun) || (defined(__NetBSD__) && __NetBSD_Version__ >= 1000000000) || defined(__midipix__) + (defined(__sun) && defined(HAVE_GETRANDOM)) || (defined(__NetBSD__) && __NetBSD_Version__ >= 1000000000) || defined(__midipix__) /* Linux getrandom(2) syscall or FreeBSD/DragonFlyBSD/NetBSD getrandom(2) function * Being a syscall, implemented in the kernel, getrandom offers higher quality output * compared to the arc4random api albeit a fallback to /dev/urandom is considered. diff --git a/ext/spl/spl_directory.c b/ext/spl/spl_directory.c index 15273cb6c46a4..989f84f1fdd1c 100644 --- a/ext/spl/spl_directory.c +++ b/ext/spl/spl_directory.c @@ -23,7 +23,7 @@ #include "ext/standard/php_filestat.h" #include "ext/standard/flock_compat.h" #include "ext/standard/scanf.h" -#include "ext/standard/php_string.h" +#include "ext/standard/php_string.h" /* For php_basename() */ #include "zend_attributes.h" #include "zend_exceptions.h" #include "zend_interfaces.h" @@ -1362,7 +1362,7 @@ PHP_METHOD(SplFileInfo, getPathInfo) path = spl_filesystem_object_get_pathname(intern); if (path && ZSTR_LEN(path)) { zend_string *dpath = zend_string_init(ZSTR_VAL(path), ZSTR_LEN(path), 0); - ZSTR_LEN(dpath) = php_dirname(ZSTR_VAL(dpath), ZSTR_LEN(path)); + ZSTR_LEN(dpath) = zend_dirname(ZSTR_VAL(dpath), ZSTR_LEN(path)); spl_filesystem_object_create_info(dpath, ce, return_value); zend_string_release(dpath); } diff --git a/ext/standard/info.c b/ext/standard/info.c index 864199d66de10..2da58f3cccef6 100644 --- a/ext/standard/info.c +++ b/ext/standard/info.c @@ -656,10 +656,16 @@ static void php_get_windows_cpu(char *buf, size_t bufsize) /* }}} */ #endif +static inline bool php_is_valid_uname_mode(char mode) { + return mode == 'a' || mode == 'm' || mode == 'n' || mode == 'r' || mode == 's' || mode == 'v'; +} + /* {{{ php_get_uname */ PHPAPI zend_string *php_get_uname(char mode) { char *php_uname; + + ZEND_ASSERT(php_is_valid_uname_mode(mode)); #ifdef PHP_WIN32 char tmp_uname[256]; DWORD dwBuild=0; @@ -680,13 +686,12 @@ PHPAPI zend_string *php_get_uname(char mode) } else if (mode == 'v') { char *winver = php_get_windows_name(); dwBuild = (DWORD)(HIWORD(dwVersion)); - if (winver == NULL) { - return strpprintf(0, "build %d", dwBuild); - } else { - zend_string *build_with_version = strpprintf(0, "build %d (%s)", dwBuild, winver); - efree(winver); - return build_with_version; - } + + ZEND_ASSERT(winver != NULL); + + zend_string *build_with_version = strpprintf(0, "build %d (%s)", dwBuild, winver); + efree(winver); + return build_with_version; } else if (mode == 'm') { php_get_windows_cpu(tmp_uname, sizeof(tmp_uname)); php_uname = tmp_uname; @@ -1314,15 +1319,26 @@ PHP_FUNCTION(php_sapi_name) /* {{{ Return information about the system PHP was built on */ PHP_FUNCTION(php_uname) { - char *mode = "a"; + char *mode_str = "a"; size_t modelen = sizeof("a")-1; ZEND_PARSE_PARAMETERS_START(0, 1) Z_PARAM_OPTIONAL - Z_PARAM_STRING(mode, modelen) + Z_PARAM_STRING(mode_str, modelen) ZEND_PARSE_PARAMETERS_END(); - RETURN_STR(php_get_uname(*mode)); + if (modelen != 1) { + zend_argument_value_error(1, "must be a single character"); + RETURN_THROWS(); + } + + char mode = *mode_str; + if (!php_is_valid_uname_mode(mode)) { + zend_argument_value_error(1, "must be one of \"a\", \"m\", \"n\", \"r\", \"s\", or \"v\""); + RETURN_THROWS(); + } + + RETURN_STR(php_get_uname(mode)); } /* }}} */ diff --git a/ext/standard/link.c b/ext/standard/link.c index 0529006d4667c..df2831b878462 100644 --- a/ext/standard/link.c +++ b/ext/standard/link.c @@ -99,8 +99,9 @@ PHP_FUNCTION(linkinfo) Z_PARAM_PATH(link, link_len) ZEND_PARSE_PARAMETERS_END(); + // TODO Check for empty string dirname = estrndup(link, link_len); - php_dirname(dirname, link_len); + zend_dirname(dirname, link_len); if (php_check_open_basedir(dirname)) { efree(dirname); @@ -141,7 +142,7 @@ PHP_FUNCTION(symlink) } memcpy(dirname, source_p, sizeof(source_p)); - len = php_dirname(dirname, strlen(dirname)); + len = zend_dirname(dirname, strlen(dirname)); if (!expand_filepath_ex(topath, dest_p, dirname, len)) { php_error_docref(NULL, E_WARNING, "No such file or directory"); diff --git a/ext/standard/tests/array/array_filter_variation9.phpt b/ext/standard/tests/array/array_filter_variation9.phpt index d9c1f9258f3a9..ff0dc7711718b 100644 --- a/ext/standard/tests/array/array_filter_variation9.phpt +++ b/ext/standard/tests/array/array_filter_variation9.phpt @@ -23,9 +23,9 @@ try { echo $e->getMessage(), "\n"; } -// using language construct 'exit' as 'callback' +// using language construct 'isset' as 'callback' try { - var_dump( array_filter($input, 'exit') ); + var_dump( array_filter($input, 'isset') ); } catch (TypeError $e) { echo $e->getMessage(), "\n"; } @@ -63,5 +63,5 @@ array(6) { int(1000) } array_filter(): Argument #2 ($callback) must be a valid callback or null, function "echo" not found or invalid function name -array_filter(): Argument #2 ($callback) must be a valid callback or null, function "exit" not found or invalid function name +array_filter(): Argument #2 ($callback) must be a valid callback or null, function "isset" not found or invalid function name Done diff --git a/ext/standard/tests/array/array_map_variation16.phpt b/ext/standard/tests/array/array_map_variation16.phpt index b7c6690040162..7ee1f04967c5c 100644 --- a/ext/standard/tests/array/array_map_variation16.phpt +++ b/ext/standard/tests/array/array_map_variation16.phpt @@ -2,32 +2,24 @@ Test array_map() function : usage variations - failing built-in functions & language constructs --FILE-- getMessage(), "\n"; } @@ -36,21 +28,11 @@ for($count = 0; $count < count($callback_names); $count++) echo "Done"; ?> --EXPECT-- -*** Testing array_map() : non-permmited built-in functions *** --- Iteration 1 -- array_map(): Argument #1 ($callback) must be a valid callback or null, function "echo" not found or invalid function name --- Iteration 2 -- array_map(): Argument #1 ($callback) must be a valid callback or null, function "array" not found or invalid function name --- Iteration 3 -- array_map(): Argument #1 ($callback) must be a valid callback or null, function "empty" not found or invalid function name --- Iteration 4 -- array_map(): Argument #1 ($callback) must be a valid callback or null, function "eval" not found or invalid function name --- Iteration 5 -- -array_map(): Argument #1 ($callback) must be a valid callback or null, function "exit" not found or invalid function name --- Iteration 6 -- array_map(): Argument #1 ($callback) must be a valid callback or null, function "isset" not found or invalid function name --- Iteration 7 -- array_map(): Argument #1 ($callback) must be a valid callback or null, function "list" not found or invalid function name --- Iteration 8 -- array_map(): Argument #1 ($callback) must be a valid callback or null, function "print" not found or invalid function name Done diff --git a/ext/standard/tests/general_functions/php_uname_error.phpt b/ext/standard/tests/general_functions/php_uname_error.phpt index 2f65ed587d36c..694ec19fb6b39 100644 --- a/ext/standard/tests/general_functions/php_uname_error.phpt +++ b/ext/standard/tests/general_functions/php_uname_error.phpt @@ -1,17 +1,26 @@ --TEST-- -Test php_uname() function - error conditions - pass function incorrect arguments +php_uname(): Invalid arguments --FILE-- getMessage(), PHP_EOL; +} +try { + var_dump(php_uname('test')); +} catch (Throwable $e) { + echo $e::class, ': ', $e->getMessage(), PHP_EOL; +} +try { + var_dump(php_uname('z')); +} catch (Throwable $e) { + echo $e::class, ': ', $e->getMessage(), PHP_EOL; +} ?> --EXPECT-- -*** Testing php_uname() - error test - --- Testing php_uname() function with invalid mode -- -bool(true) +ValueError: php_uname(): Argument #1 ($mode) must be a single character +ValueError: php_uname(): Argument #1 ($mode) must be a single character +ValueError: php_uname(): Argument #1 ($mode) must be one of "a", "m", "n", "r", "s", or "v" diff --git a/ext/xmlwriter/php_xmlwriter.c b/ext/xmlwriter/php_xmlwriter.c index bbb4b94814a48..6724f4fbfbffb 100644 --- a/ext/xmlwriter/php_xmlwriter.c +++ b/ext/xmlwriter/php_xmlwriter.c @@ -24,7 +24,6 @@ #include "ext/standard/info.h" #include "php_xmlwriter.h" #include "php_xmlwriter_arginfo.h" -#include "ext/standard/php_string.h" /* For php_dirname() */ static zend_class_entry *xmlwriter_class_entry_ce; @@ -158,7 +157,7 @@ static char *_xmlwriter_get_valid_file_path(char *source, char *resolved_path, i } memcpy(file_dirname, source, strlen(source)); - dir_len = php_dirname(file_dirname, strlen(source)); + dir_len = zend_dirname(file_dirname, strlen(source)); if (dir_len > 0) { zend_stat_t buf = {0}; diff --git a/ext/zip/php_zip.c b/ext/zip/php_zip.c index 5d331c2fa4b82..342d6aabe7240 100644 --- a/ext/zip/php_zip.c +++ b/ext/zip/php_zip.c @@ -171,7 +171,7 @@ static int php_zip_extract_file(struct zip * za, char *dest, const char *file, s is_dir_only = 1; } else { memcpy(file_dirname, path_cleaned, path_cleaned_len); - dir_len = php_dirname(file_dirname, path_cleaned_len); + dir_len = zend_dirname(file_dirname, path_cleaned_len); if (!dir_len || (dir_len == 1 && file_dirname[0] == '.')) { len = spprintf(&file_dirname_fullpath, 0, "%s", dest); diff --git a/sapi/cli/php_cli_server.c b/sapi/cli/php_cli_server.c index bd030c2010349..a720ce32e356c 100644 --- a/sapi/cli/php_cli_server.c +++ b/sapi/cli/php_cli_server.c @@ -95,7 +95,6 @@ #include "zend_smart_str.h" #include "ext/standard/html.h" #include "ext/standard/url.h" /* for php_raw_url_decode() */ -#include "ext/standard/php_string.h" /* for php_dirname() */ #include "ext/date/php_date.h" /* for php_format_date() */ #include "php_network.h" diff --git a/sapi/embed/config.m4 b/sapi/embed/config.m4 index ef9956763d3a4..86856124f2327 100644 --- a/sapi/embed/config.m4 +++ b/sapi/embed/config.m4 @@ -8,29 +8,27 @@ PHP_ARG_ENABLE([embed],, AC_MSG_CHECKING([for embedded SAPI library support]) if test "$PHP_EMBED" != "no"; then - case "$PHP_EMBED" in - yes|shared) + AS_CASE([$PHP_EMBED], + [yes|shared], [ LIBPHP_CFLAGS="-shared" PHP_EMBED_TYPE=shared INSTALL_IT="\$(mkinstalldirs) \$(INSTALL_ROOT)\$(orig_libdir); \$(INSTALL) -m 0755 $SAPI_SHARED \$(INSTALL_ROOT)\$(orig_libdir)" - ;; - static) + ], + [static], [ LIBPHP_CFLAGS="-static" PHP_EMBED_TYPE=static INSTALL_IT="\$(mkinstalldirs) \$(INSTALL_ROOT)\$(orig_libdir); \$(INSTALL) -m 0644 $SAPI_STATIC \$(INSTALL_ROOT)\$(orig_libdir)" - ;; - *) - PHP_EMBED_TYPE=no - ;; - esac - if test "$PHP_EMBED_TYPE" != "no"; then + ], + [PHP_EMBED_TYPE=no]) + + AS_VAR_IF([PHP_EMBED_TYPE], [no],, [ PHP_SUBST([LIBPHP_CFLAGS]) PHP_SELECT_SAPI([embed], [$PHP_EMBED_TYPE], [php_embed.c], [-DZEND_ENABLE_STATIC_TSRMLS_CACHE=1]) PHP_INSTALL_HEADERS([sapi/embed], [php_embed.h]) - fi + ]) AC_MSG_RESULT([$PHP_EMBED_TYPE]) AC_SUBST([PHP_EMBED_TYPE]) else diff --git a/sapi/fpm/tests/main-version.phpt b/sapi/fpm/tests/main-version.phpt index 40ea45ef01026..5ae83562d070b 100644 --- a/sapi/fpm/tests/main-version.phpt +++ b/sapi/fpm/tests/main-version.phpt @@ -16,6 +16,6 @@ echo "Done\n"; --EXPECTF-- string(%d) "PHP %s (fpm%s (built: %s Copyright (c) The PHP Group -Zend Engine v%s, Copyright (c) Zend Technologies +%AZend Engine v%s, Copyright (c) Zend Technologies " Done diff --git a/sapi/phpdbg/phpdbg_prompt.c b/sapi/phpdbg/phpdbg_prompt.c index d3a3ea2144548..2314068044fb8 100644 --- a/sapi/phpdbg/phpdbg_prompt.c +++ b/sapi/phpdbg/phpdbg_prompt.c @@ -608,7 +608,6 @@ int phpdbg_skip_line_helper(void) /* {{{ */ { || opline->opcode == ZEND_RETURN || opline->opcode == ZEND_FAST_RET || opline->opcode == ZEND_GENERATOR_RETURN - || opline->opcode == ZEND_EXIT || opline->opcode == ZEND_YIELD || opline->opcode == ZEND_YIELD_FROM ) { @@ -652,7 +651,6 @@ static void phpdbg_seek_to_end(void) /* {{{ */ { case ZEND_RETURN: case ZEND_FAST_RET: case ZEND_GENERATOR_RETURN: - case ZEND_EXIT: case ZEND_YIELD: case ZEND_YIELD_FROM: zend_hash_index_update_ptr(&PHPDBG_G(seek), (zend_ulong) opline, (void *) opline);