From 2a1212402197fae22b6e6aa2a5d74ceb1088fecf Mon Sep 17 00:00:00 2001 From: George Peter Banyard Date: Sat, 13 Feb 2021 05:22:45 +0000 Subject: [PATCH 01/13] Remove duplicate testing conditions --- ext/date/tests/bug67118.phpt | 2 +- ext/standard/tests/array/array_walk_error2.phpt | 15 --------------- .../tests/array/array_walk_recursive_error2.phpt | 15 --------------- 3 files changed, 1 insertion(+), 31 deletions(-) diff --git a/ext/date/tests/bug67118.phpt b/ext/date/tests/bug67118.phpt index ee1d8efc0aa32..a9db7dc5d925e 100644 --- a/ext/date/tests/bug67118.phpt +++ b/ext/date/tests/bug67118.phpt @@ -12,7 +12,7 @@ class mydt extends datetime $tz = new DateTimeZone($tz); } try { - @parent::__construct($time, $tz); + parent::__construct($time, $tz); } catch (Exception $e) { echo "Bad date" . $this->format("Y") . "\n"; } diff --git a/ext/standard/tests/array/array_walk_error2.phpt b/ext/standard/tests/array/array_walk_error2.phpt index 57b082db95aff..ef47a4fb9aa39 100644 --- a/ext/standard/tests/array/array_walk_error2.phpt +++ b/ext/standard/tests/array/array_walk_error2.phpt @@ -16,7 +16,6 @@ function callback2($value, $key, $user_data1, $user_data2) { } echo "*** Testing array_walk() : error conditions - callback parameters ***\n"; -// expected: Missing argument Warning try { var_dump( array_walk($input, "callback1") ); } catch (Throwable $e) { @@ -28,18 +27,6 @@ try { echo "Exception: " . $e->getMessage() . "\n"; } -// expected: Warning is suppressed -try { - var_dump( @array_walk($input, "callback1") ); -} catch (Throwable $e) { - echo "Exception: " . $e->getMessage() . "\n"; -} -try { - var_dump( @array_walk($input, "callback2", 4) ); -} catch (Throwable $e) { - echo "Exception: " . $e->getMessage() . "\n"; -} - echo "-- Testing array_walk() function with too many callback parameters --\n"; try { var_dump( array_walk($input, "callback1", 20, 10) ); @@ -53,8 +40,6 @@ echo "Done"; *** Testing array_walk() : error conditions - callback parameters *** Exception: Too few arguments to function callback1(), 2 passed and exactly 3 expected Exception: Too few arguments to function callback2(), 3 passed and exactly 4 expected -Exception: Too few arguments to function callback1(), 2 passed and exactly 3 expected -Exception: Too few arguments to function callback2(), 3 passed and exactly 4 expected -- Testing array_walk() function with too many callback parameters -- Exception: array_walk() expects at most 3 arguments, 4 given Done diff --git a/ext/standard/tests/array/array_walk_recursive_error2.phpt b/ext/standard/tests/array/array_walk_recursive_error2.phpt index fa5161e5c1bd9..ab55785227be2 100644 --- a/ext/standard/tests/array/array_walk_recursive_error2.phpt +++ b/ext/standard/tests/array/array_walk_recursive_error2.phpt @@ -16,7 +16,6 @@ function callback2($value, $key, $user_data1, $user_data2) { } echo "*** Testing array_walk_recursive() : error conditions - callback parameters ***\n"; -// expected: Missing argument Warning try { var_dump( array_walk_recursive($input, "callback1") ); } catch (Throwable $e) { @@ -28,18 +27,6 @@ try { echo "Exception: " . $e->getMessage() . "\n"; } -// expected: Warning is suppressed -try { - var_dump( @array_walk_recursive($input, "callback1") ); -} catch (Throwable $e) { - echo "Exception: " . $e->getMessage() . "\n"; -} -try { - var_dump( @array_walk_recursive($input, "callback2", 4) ); -} catch (Throwable $e) { - echo "Exception: " . $e->getMessage() . "\n"; -} - echo "-- Testing array_walk_recursive() function with too many callback parameters --\n"; try { var_dump( array_walk_recursive($input, "callback1", 20, 10) ); @@ -53,8 +40,6 @@ echo "Done"; *** Testing array_walk_recursive() : error conditions - callback parameters *** Exception: Too few arguments to function callback1(), 2 passed and exactly 3 expected Exception: Too few arguments to function callback2(), 3 passed and exactly 4 expected -Exception: Too few arguments to function callback1(), 2 passed and exactly 3 expected -Exception: Too few arguments to function callback2(), 3 passed and exactly 4 expected -- Testing array_walk_recursive() function with too many callback parameters -- Exception: array_walk_recursive() expects at most 3 arguments, 4 given Done From 452d0b92372d246981c73eeb7cfa9ed0ef4cef37 Mon Sep 17 00:00:00 2001 From: George Peter Banyard Date: Wed, 2 Dec 2020 17:51:50 +0000 Subject: [PATCH 02/13] Suppress exceptions with @ or @ --- .../constructor_throwing.phpt | 20 + .../empty_exception_list.phpt | 18 + .../exception_in_function_call.phpt | 19 + Zend/tests/silence_operator/foreach.phpt | 18 + .../in_try_catch_diagnostic.phpt | 18 + .../in_try_catch_exception.phpt | 23 + .../internal_function_arg_diagnostic.phpt | 12 + .../internal_function_arg_exception.phpt | 17 + .../listed_exceptions_in.phpt | 19 + .../listed_exceptions_not_in.phpt | 22 + .../nested_silence_in_call.phpt | 25 + .../silence_function_many_ops.phpt | 22 + .../silence_function_nested.phpt | 24 + .../silence_multiple_use.phpt | 14 + .../silence_multiple_use_exception.phpt | 19 + .../silence_operator/throw_expression.phpt | 14 + Zend/tests/silence_operator/undef_var.phpt | 14 + .../user_function_arg_diagnostic.phpt | 18 + .../user_function_arg_exception.phpt | 23 + Zend/tests/silence_operator/yield.phpt | 27 + .../yield_from_function_which_throws.phpt | 30 + .../yield_from_silenced_non_iterable.phpt | 25 + .../silence_operator/yield_from_throw.phpt | 29 + Zend/tests/silence_operator/yield_throw.phpt | 22 + Zend/tests/throw/leaks.phpt | 2 +- .../union_types/type_checking_strict.phpt | 2 +- .../union_types/type_checking_weak.phpt | 2 +- .../uncaught_exception_error_supression.phpt | 18 - Zend/zend_ast.c | 12 +- Zend/zend_ast.h | 2 +- Zend/zend_compile.c | 77 +- Zend/zend_execute.c | 12 + Zend/zend_language_parser.y | 12 +- Zend/zend_language_scanner.l | 4 + Zend/zend_vm_def.h | 58 +- Zend/zend_vm_execute.h | 256 +++-- Zend/zend_vm_handlers.h | 917 +++++++++--------- Zend/zend_vm_opcodes.c | 6 +- Zend/zend_vm_opcodes.h | 3 +- ext/tokenizer/tokenizer_data.c | 2 + ext/zend_test/test.c | 23 + ext/zend_test/test.stub.php | 4 + ext/zend_test/test_arginfo.h | 20 +- ...press_exception_internal_return_false.phpt | 23 + ...uppress_exception_internal_return_int.phpt | 25 + ...ppress_exception_internal_return_true.phpt | 25 + 46 files changed, 1404 insertions(+), 593 deletions(-) create mode 100644 Zend/tests/silence_operator/constructor_throwing.phpt create mode 100644 Zend/tests/silence_operator/empty_exception_list.phpt create mode 100644 Zend/tests/silence_operator/exception_in_function_call.phpt create mode 100644 Zend/tests/silence_operator/foreach.phpt create mode 100644 Zend/tests/silence_operator/in_try_catch_diagnostic.phpt create mode 100644 Zend/tests/silence_operator/in_try_catch_exception.phpt create mode 100644 Zend/tests/silence_operator/internal_function_arg_diagnostic.phpt create mode 100644 Zend/tests/silence_operator/internal_function_arg_exception.phpt create mode 100644 Zend/tests/silence_operator/listed_exceptions_in.phpt create mode 100644 Zend/tests/silence_operator/listed_exceptions_not_in.phpt create mode 100644 Zend/tests/silence_operator/nested_silence_in_call.phpt create mode 100644 Zend/tests/silence_operator/silence_function_many_ops.phpt create mode 100644 Zend/tests/silence_operator/silence_function_nested.phpt create mode 100644 Zend/tests/silence_operator/silence_multiple_use.phpt create mode 100644 Zend/tests/silence_operator/silence_multiple_use_exception.phpt create mode 100644 Zend/tests/silence_operator/throw_expression.phpt create mode 100644 Zend/tests/silence_operator/undef_var.phpt create mode 100644 Zend/tests/silence_operator/user_function_arg_diagnostic.phpt create mode 100644 Zend/tests/silence_operator/user_function_arg_exception.phpt create mode 100644 Zend/tests/silence_operator/yield.phpt create mode 100644 Zend/tests/silence_operator/yield_from_function_which_throws.phpt create mode 100644 Zend/tests/silence_operator/yield_from_silenced_non_iterable.phpt create mode 100644 Zend/tests/silence_operator/yield_from_throw.phpt create mode 100644 Zend/tests/silence_operator/yield_throw.phpt delete mode 100644 Zend/tests/uncaught_exception_error_supression.phpt create mode 100644 ext/zend_test/tests/suppress_exception_internal_return_false.phpt create mode 100644 ext/zend_test/tests/suppress_exception_internal_return_int.phpt create mode 100644 ext/zend_test/tests/suppress_exception_internal_return_true.phpt diff --git a/Zend/tests/silence_operator/constructor_throwing.phpt b/Zend/tests/silence_operator/constructor_throwing.phpt new file mode 100644 index 0000000000000..ce2afe613d8cf --- /dev/null +++ b/Zend/tests/silence_operator/constructor_throwing.phpt @@ -0,0 +1,20 @@ +--TEST-- +Silencing a new object instance +--FILE-- + +--EXPECT-- +NULL +Done diff --git a/Zend/tests/silence_operator/empty_exception_list.phpt b/Zend/tests/silence_operator/empty_exception_list.phpt new file mode 100644 index 0000000000000..c10a9cfec5888 --- /dev/null +++ b/Zend/tests/silence_operator/empty_exception_list.phpt @@ -0,0 +1,18 @@ +--TEST-- +Suppression operator ParseError with empty class list +--FILE-- +test1(); + +var_dump($var); + +echo "Done\n"; +?> +--EXPECTF-- +Parse error: syntax error, unexpected token ">" in %s on line 8 diff --git a/Zend/tests/silence_operator/exception_in_function_call.phpt b/Zend/tests/silence_operator/exception_in_function_call.phpt new file mode 100644 index 0000000000000..900c69711f7f9 --- /dev/null +++ b/Zend/tests/silence_operator/exception_in_function_call.phpt @@ -0,0 +1,19 @@ +--TEST-- +Silence exception with @ operator +--FILE-- + +--EXPECT-- +NULL +Done diff --git a/Zend/tests/silence_operator/foreach.phpt b/Zend/tests/silence_operator/foreach.phpt new file mode 100644 index 0000000000000..b78b4865bc4db --- /dev/null +++ b/Zend/tests/silence_operator/foreach.phpt @@ -0,0 +1,18 @@ +--TEST-- +Use of @ before foreach value to iterator upon +--FILE-- + +--EXPECTF-- +Warning: foreach() argument must be of type array|object, null given in %s on line %d +Done diff --git a/Zend/tests/silence_operator/in_try_catch_diagnostic.phpt b/Zend/tests/silence_operator/in_try_catch_diagnostic.phpt new file mode 100644 index 0000000000000..9435690e8928f --- /dev/null +++ b/Zend/tests/silence_operator/in_try_catch_diagnostic.phpt @@ -0,0 +1,18 @@ +--TEST-- +Use of @ in try catch must not fail when a diagnostic is emitted +--FILE-- + +--EXPECT-- +NULL +Done diff --git a/Zend/tests/silence_operator/in_try_catch_exception.phpt b/Zend/tests/silence_operator/in_try_catch_exception.phpt new file mode 100644 index 0000000000000..03d05fc2f88e7 --- /dev/null +++ b/Zend/tests/silence_operator/in_try_catch_exception.phpt @@ -0,0 +1,23 @@ +--TEST-- +Use of @ in try catch must not fail when an exception is thrown +--FILE-- + +--EXPECT-- +NULL +Done diff --git a/Zend/tests/silence_operator/internal_function_arg_diagnostic.phpt b/Zend/tests/silence_operator/internal_function_arg_diagnostic.phpt new file mode 100644 index 0000000000000..854cd75bc873c --- /dev/null +++ b/Zend/tests/silence_operator/internal_function_arg_diagnostic.phpt @@ -0,0 +1,12 @@ +--TEST-- +Silencing an internal function argument emitting a diagnostic +--FILE-- + +--EXPECT-- +NULL +Done diff --git a/Zend/tests/silence_operator/internal_function_arg_exception.phpt b/Zend/tests/silence_operator/internal_function_arg_exception.phpt new file mode 100644 index 0000000000000..93aed25ecab06 --- /dev/null +++ b/Zend/tests/silence_operator/internal_function_arg_exception.phpt @@ -0,0 +1,17 @@ +--TEST-- +Silencing an internal function argument throwing an Exception +--FILE-- + +--EXPECT-- +NULL +Done diff --git a/Zend/tests/silence_operator/listed_exceptions_in.phpt b/Zend/tests/silence_operator/listed_exceptions_in.phpt new file mode 100644 index 0000000000000..ee13dea5fef69 --- /dev/null +++ b/Zend/tests/silence_operator/listed_exceptions_in.phpt @@ -0,0 +1,19 @@ +--TEST-- +Suppression operator with class list, single +--FILE-- +test1(); + +var_dump($var); + +echo "Done\n"; +?> +--EXPECT-- +NULL +Done diff --git a/Zend/tests/silence_operator/listed_exceptions_not_in.phpt b/Zend/tests/silence_operator/listed_exceptions_not_in.phpt new file mode 100644 index 0000000000000..a853370d01f0f --- /dev/null +++ b/Zend/tests/silence_operator/listed_exceptions_not_in.phpt @@ -0,0 +1,22 @@ +--TEST-- +Suppression operator should only suppress listed Exceptions +--FILE-- +test1(); + +var_dump($var); + +echo "Done\n"; +?> +--EXPECTF-- +Fatal error: Uncaught Error in %s:4 +Stack trace: +#0 %s(8): test1() +#1 {main} + thrown in %s on line 4 diff --git a/Zend/tests/silence_operator/nested_silence_in_call.phpt b/Zend/tests/silence_operator/nested_silence_in_call.phpt new file mode 100644 index 0000000000000..f7d277b6d2975 --- /dev/null +++ b/Zend/tests/silence_operator/nested_silence_in_call.phpt @@ -0,0 +1,25 @@ +--TEST-- +Nested at in call must not fail +--FILE-- + +--EXPECT-- +NULL +Done diff --git a/Zend/tests/silence_operator/silence_function_many_ops.phpt b/Zend/tests/silence_operator/silence_function_many_ops.phpt new file mode 100644 index 0000000000000..c9677ff86483f --- /dev/null +++ b/Zend/tests/silence_operator/silence_function_many_ops.phpt @@ -0,0 +1,22 @@ +--TEST-- +Silence function with ops before exception with @ operator +--FILE-- + +--EXPECT-- +NULL +Done diff --git a/Zend/tests/silence_operator/silence_function_nested.phpt b/Zend/tests/silence_operator/silence_function_nested.phpt new file mode 100644 index 0000000000000..19126bce3c3ab --- /dev/null +++ b/Zend/tests/silence_operator/silence_function_nested.phpt @@ -0,0 +1,24 @@ +--TEST-- +Silence nested function call which throws with @ operator +--FILE-- + +--EXPECT-- +NULL +Done diff --git a/Zend/tests/silence_operator/silence_multiple_use.phpt b/Zend/tests/silence_operator/silence_multiple_use.phpt new file mode 100644 index 0000000000000..75b85416a0086 --- /dev/null +++ b/Zend/tests/silence_operator/silence_multiple_use.phpt @@ -0,0 +1,14 @@ +--TEST-- +Multiple use of @ operator must not fail to suppress diagnostic +--FILE-- + +--EXPECT-- +NULL +Done diff --git a/Zend/tests/silence_operator/silence_multiple_use_exception.phpt b/Zend/tests/silence_operator/silence_multiple_use_exception.phpt new file mode 100644 index 0000000000000..bbcb9bff7f77f --- /dev/null +++ b/Zend/tests/silence_operator/silence_multiple_use_exception.phpt @@ -0,0 +1,19 @@ +--TEST-- +Multiple use of @ operator must not fail to suppress diagnostic +--FILE-- + +--EXPECT-- +NULL +Done diff --git a/Zend/tests/silence_operator/throw_expression.phpt b/Zend/tests/silence_operator/throw_expression.phpt new file mode 100644 index 0000000000000..382f1395b5d39 --- /dev/null +++ b/Zend/tests/silence_operator/throw_expression.phpt @@ -0,0 +1,14 @@ +--TEST-- +Silence throw with @ operator +--FILE-- + +--EXPECT-- +NULL +Done diff --git a/Zend/tests/silence_operator/undef_var.phpt b/Zend/tests/silence_operator/undef_var.phpt new file mode 100644 index 0000000000000..3604a81737ab1 --- /dev/null +++ b/Zend/tests/silence_operator/undef_var.phpt @@ -0,0 +1,14 @@ +--TEST-- +Silence undef variable with @ operator +--FILE-- + +--EXPECT-- +NULL +Done diff --git a/Zend/tests/silence_operator/user_function_arg_diagnostic.phpt b/Zend/tests/silence_operator/user_function_arg_diagnostic.phpt new file mode 100644 index 0000000000000..7ff71068fc05f --- /dev/null +++ b/Zend/tests/silence_operator/user_function_arg_diagnostic.phpt @@ -0,0 +1,18 @@ +--TEST-- +Silencing a userland function argument emitting a diagnostic +--FILE-- + +--EXPECT-- +NULL +Done diff --git a/Zend/tests/silence_operator/user_function_arg_exception.phpt b/Zend/tests/silence_operator/user_function_arg_exception.phpt new file mode 100644 index 0000000000000..47822492b022c --- /dev/null +++ b/Zend/tests/silence_operator/user_function_arg_exception.phpt @@ -0,0 +1,23 @@ +--TEST-- +Silencing a userland function argument throwing an Exception +--FILE-- + +--EXPECT-- +NULL +Done diff --git a/Zend/tests/silence_operator/yield.phpt b/Zend/tests/silence_operator/yield.phpt new file mode 100644 index 0000000000000..6f96df8be4f2d --- /dev/null +++ b/Zend/tests/silence_operator/yield.phpt @@ -0,0 +1,27 @@ +--TEST-- +Use of @ before calling generator in foreach throws +--XFAIL-- +Not sure what the correct behaviour is meant to be +--FILE-- + +--EXPECT-- +int(1) + +Fatal error: Uncaught Exception in /home/girgias/Dev/php-src/Zend/tests/silence_operator/yield.php:5 +Stack trace: +#0 /home/girgias/Dev/php-src/Zend/tests/silence_operator/yield.php(9): generator() +#1 {main} + thrown in /home/girgias/Dev/php-src/Zend/tests/silence_operator/yield.php on line 5 diff --git a/Zend/tests/silence_operator/yield_from_function_which_throws.phpt b/Zend/tests/silence_operator/yield_from_function_which_throws.phpt new file mode 100644 index 0000000000000..fb44fe799a5f6 --- /dev/null +++ b/Zend/tests/silence_operator/yield_from_function_which_throws.phpt @@ -0,0 +1,30 @@ +--TEST-- +yield from @expr throws +--FILE-- + +--EXPECTF-- +int(1) + +Fatal error: Uncaught Error: Can use "yield from" only with arrays and Traversables in %s:%d +Stack trace: +#0 %s(%d): generator() +#1 {main} + thrown in %s on line %d diff --git a/Zend/tests/silence_operator/yield_from_silenced_non_iterable.phpt b/Zend/tests/silence_operator/yield_from_silenced_non_iterable.phpt new file mode 100644 index 0000000000000..ad9f4b4935b34 --- /dev/null +++ b/Zend/tests/silence_operator/yield_from_silenced_non_iterable.phpt @@ -0,0 +1,25 @@ +--TEST-- +Silence yield from not an iterable +--FILE-- + +--EXPECT-- +int(1) +int(2) +Done diff --git a/Zend/tests/silence_operator/yield_from_throw.phpt b/Zend/tests/silence_operator/yield_from_throw.phpt new file mode 100644 index 0000000000000..8470783d318f6 --- /dev/null +++ b/Zend/tests/silence_operator/yield_from_throw.phpt @@ -0,0 +1,29 @@ +--TEST-- +yield from @throw new Exception +--FILE-- + +--EXPECTF-- +int(1) + +Fatal error: Uncaught Error: Can use "yield from" only with arrays and Traversables in %s:%d +Stack trace: +#0 %s(%d): generator() +#1 {main} + thrown in %s on line %d diff --git a/Zend/tests/silence_operator/yield_throw.phpt b/Zend/tests/silence_operator/yield_throw.phpt new file mode 100644 index 0000000000000..9b6d52282d5df --- /dev/null +++ b/Zend/tests/silence_operator/yield_throw.phpt @@ -0,0 +1,22 @@ +--TEST-- +yield @throw new Exception +--FILE-- + +--EXPECT-- +int(1) +NULL +int(2) +Done diff --git a/Zend/tests/throw/leaks.phpt b/Zend/tests/throw/leaks.phpt index 0f9311a820c04..767215c570aad 100644 --- a/Zend/tests/throw/leaks.phpt +++ b/Zend/tests/throw/leaks.phpt @@ -17,7 +17,7 @@ try { } try { - @throw new Exception; + ~throw new Exception; } catch (Exception $e) { echo "Caught\n"; } diff --git a/Zend/tests/type_declarations/union_types/type_checking_strict.phpt b/Zend/tests/type_declarations/union_types/type_checking_strict.phpt index 7054a7cc19127..ca8739452eefe 100644 --- a/Zend/tests/type_declarations/union_types/type_checking_strict.phpt +++ b/Zend/tests/type_declarations/union_types/type_checking_strict.phpt @@ -25,7 +25,7 @@ function test(string $type, array $values) { try { error_clear_last(); - $value = @$fn($value); + $value = $fn($value); echo dump($value); if ($e = error_get_last()) { echo ' (', $e['message'], ')'; diff --git a/Zend/tests/type_declarations/union_types/type_checking_weak.phpt b/Zend/tests/type_declarations/union_types/type_checking_weak.phpt index 351a3e9e78ede..33aaeeefae517 100644 --- a/Zend/tests/type_declarations/union_types/type_checking_weak.phpt +++ b/Zend/tests/type_declarations/union_types/type_checking_weak.phpt @@ -23,7 +23,7 @@ function test(string $type, array $values) { try { error_clear_last(); - $value = @$fn($value); + $value = $fn($value); echo dump($value); if ($e = error_get_last()) { echo ' (', $e['message'], ')'; diff --git a/Zend/tests/uncaught_exception_error_supression.phpt b/Zend/tests/uncaught_exception_error_supression.phpt deleted file mode 100644 index 1130a9d99b0d4..0000000000000 --- a/Zend/tests/uncaught_exception_error_supression.phpt +++ /dev/null @@ -1,18 +0,0 @@ ---TEST-- -Error suppression should have no impact on uncaught exceptions ---FILE-- - ---EXPECTF-- -Fatal error: Uncaught Error: Example Exception in %s:%d -Stack trace: -#0 %s(%d): abc() -#1 {main} - thrown in %s on line %d diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c index 6bdf0c4e38883..64ef08522e91f 100644 --- a/Zend/zend_ast.c +++ b/Zend/zend_ast.c @@ -1950,8 +1950,6 @@ static ZEND_COLD void zend_ast_export_ex(smart_str *str, zend_ast *ast, int prio FUNC_OP("empty"); case ZEND_AST_ISSET: FUNC_OP("isset"); - case ZEND_AST_SILENCE: - PREFIX_OP("@", 240, 241); case ZEND_AST_SHELL_EXEC: smart_str_appendc(str, '`'); if (ast->child[0]->kind == ZEND_AST_ENCAPS_LIST) { @@ -2335,6 +2333,16 @@ static ZEND_COLD void zend_ast_export_ex(smart_str *str, zend_ast *ast, int prio smart_str_appends(str, ": "); ast = ast->child[1]; goto tail_call; + case ZEND_AST_SILENCE: + smart_str_appends(str, "@"); + if (ast->child[1]) { + smart_str_appends(str, "<"); + zend_ast_export_catch_name_list(str, zend_ast_get_list(ast->child[0]), indent); + smart_str_appends(str, ">"); + } + /* Expression is the first child of the AST even if it comes after */ + zend_ast_export_ex(str, ast->child[0], 0, indent); + break; /* 3 child nodes */ case ZEND_AST_METHOD_CALL: diff --git a/Zend/zend_ast.h b/Zend/zend_ast.h index d2940bbe633a8..9dcd4ee105d31 100644 --- a/Zend/zend_ast.h +++ b/Zend/zend_ast.h @@ -82,7 +82,6 @@ enum _zend_ast_kind { ZEND_AST_CAST, ZEND_AST_EMPTY, ZEND_AST_ISSET, - ZEND_AST_SILENCE, ZEND_AST_SHELL_EXEC, ZEND_AST_CLONE, ZEND_AST_EXIT, @@ -129,6 +128,7 @@ enum _zend_ast_kind { ZEND_AST_YIELD, ZEND_AST_COALESCE, ZEND_AST_ASSIGN_COALESCE, + ZEND_AST_SILENCE, ZEND_AST_STATIC, ZEND_AST_WHILE, diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index ff7c9b152cd7e..3721b58de3bff 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -4984,7 +4984,7 @@ static void zend_compile_throw(znode *result, zend_ast *ast) /* {{{ */ /* 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); + ZVAL_NULL(&result->u.constant); } } /* }}} */ @@ -9332,6 +9332,14 @@ static void zend_compile_silence(znode *result, zend_ast *ast) /* {{{ */ { zend_ast *expr_ast = ast->child[0]; znode silence_node; + zend_op *silence_catch_op; + uint32_t try_catch_offset; + uint32_t virtual_catch_op_num; + uint32_t silence_catch_op_num; + + /* Insert virtual try */ + try_catch_offset = zend_add_try_element(get_next_op_number()); + CG(context).try_catch_offset = try_catch_offset; zend_emit_op_tmp(&silence_node, ZEND_BEGIN_SILENCE, NULL, NULL); @@ -9344,6 +9352,73 @@ static void zend_compile_silence(znode *result, zend_ast *ast) /* {{{ */ } zend_emit_op(NULL, ZEND_END_SILENCE, &silence_node, NULL); + + /* Fetch next OPcode number */ + silence_catch_op_num = get_next_op_number(); + silence_catch_op = zend_emit_op(NULL, ZEND_SILENCE_CATCH, NULL, NULL); + + SET_NODE(silence_catch_op->result, result); + + /* Emit catch OPcodes */ + /* Jump for virtual catch block */ + virtual_catch_op_num = zend_emit_jump(0); + + /* Have classes been provided using @expr */ + if (ast->child[1] != NULL) { + zend_ast_list *classes = zend_ast_get_list(ast->child[1]); + uint32_t opnum_catch = (uint32_t)-1; + + /* Inform SILENCE_CATCH opcode that there is an exception class list */ + silence_catch_op->extended_value = 2; + + ZEND_ASSERT(classes->children > 0 && "Should have at least one class"); + + for (uint32_t j = 0; j < classes->children; j++) { + zend_ast *class_ast = classes->child[j]; + zend_op *opline; + bool is_last_class = (j + 1 == classes->children); + + if (!zend_is_const_default_class_ref(class_ast)) { + zend_error_noreturn(E_COMPILE_ERROR, "Bad class name in the catch statement"); + } + + opnum_catch = get_next_op_number(); + + /* If this is the first virtual catch block, propagate info for try catch ketchup */ + if (j == 0) { + CG(active_op_array)->try_catch_array[try_catch_offset].catch_op = opnum_catch; + } + + /* Create ZEND_CATCH opcode */ + opline = get_next_op(); + opline->opcode = ZEND_CATCH; + opline->op1_type = IS_CONST; + opline->op1.constant = zend_add_class_name_literal( + zend_resolve_class_name_ast(class_ast)); + opline->extended_value = zend_alloc_cache_slot(); + + opline->result_type = IS_UNUSED; + opline->result.var = -1; + + /* Jump to silence catch block */ + if (is_last_class) { + opline->extended_value |= ZEND_LAST_CATCH; + /* Jump to SILENCE_CATCH opcode to set a return value */ + zend_emit_jump(silence_catch_op_num); + } else { + /* Set JMP address for next catch block, + * we can do this as the catch blocks are virtual and have no body. */ + opline->op2.opline_num = get_next_op_number(); + } + } + } else { + /* TODO Try to use ZEND_DISCARD_EXCEPTION OPCode? */ + /* Propagate info for try catch ketchup */ + CG(active_op_array)->try_catch_array[try_catch_offset].catch_op = silence_catch_op_num; + } + + /* Update catch jump op num ? */ + zend_update_jump_target_to_next(virtual_catch_op_num); } /* }}} */ diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index adc875e2a7736..7c566adfca586 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -4222,6 +4222,18 @@ static const zend_live_range *find_live_range(const zend_op_array *op_array, uin } /* }}} */ +/* TODO Can this be done using find_live_range? */ +static bool is_in_silence_live_range(const zend_op_array op_array, uint32_t op_num) { + for (int i = 0; i < op_array.last_live_range; i++) { + zend_live_range range = op_array.live_range[i]; + if (op_num >= range.start && op_num < range.end + && (range.var & ZEND_LIVE_MASK) == ZEND_LIVE_SILENCE) { + return true; + } + } + return false; +} + static void cleanup_live_vars(zend_execute_data *execute_data, uint32_t op_num, uint32_t catch_op_num) /* {{{ */ { int i; diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y index 3ce6a38d0d4a4..51c8c73eee138 100644 --- a/Zend/zend_language_parser.y +++ b/Zend/zend_language_parser.y @@ -240,6 +240,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); * It will be fixed up by zend_yytnamerr() later. */ %token T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG "amp" %token T_BAD_CHARACTER "invalid character" +%token T_SILENCE_LIST "@<" /* Token used to force a parse error from the lexer */ %token T_ERROR @@ -264,7 +265,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %type encaps_var encaps_var_offset isset_variables %type top_statement_list use_declarations const_list inner_statement_list if_stmt %type alt_if_stmt for_exprs switch_case_list global_var_list static_var_list -%type echo_expr_list unset_variables catch_name_list catch_list optional_variable parameter_list class_statement_list +%type echo_expr_list unset_variables class_name_union catch_list optional_variable parameter_list class_statement_list %type implements_list case_list if_stmt_without_else %type non_empty_parameter_list argument_list non_empty_argument_list property_list %type class_const_list class_const_decl class_name_list trait_adaptations method_body non_empty_for_exprs @@ -532,13 +533,13 @@ statement: catch_list: %empty { $$ = zend_ast_create_list(0, ZEND_AST_CATCH_LIST); } - | catch_list T_CATCH '(' catch_name_list optional_variable ')' '{' inner_statement_list '}' + | catch_list T_CATCH '(' class_name_union optional_variable ')' '{' inner_statement_list '}' { $$ = zend_ast_list_add($1, zend_ast_create(ZEND_AST_CATCH, $4, $5, $8)); } ; -catch_name_list: +class_name_union: class_name { $$ = zend_ast_create_list(1, ZEND_AST_NAME_LIST, $1); } - | catch_name_list '|' class_name { $$ = zend_ast_list_add($1, $3); } + | class_name_union '|' class_name { $$ = zend_ast_list_add($1, $3); } ; optional_variable: @@ -1195,7 +1196,8 @@ expr: | T_BOOL_CAST expr { $$ = zend_ast_create_cast(_IS_BOOL, $2); } | T_UNSET_CAST expr { $$ = zend_ast_create_cast(IS_NULL, $2); } | T_EXIT exit_expr { $$ = zend_ast_create(ZEND_AST_EXIT, $2); } - | '@' expr { $$ = zend_ast_create(ZEND_AST_SILENCE, $2); } + | T_SILENCE_LIST class_name_union '>' expr { $$ = zend_ast_create(ZEND_AST_SILENCE, $4, $2); } + | '@' expr { $$ = zend_ast_create(ZEND_AST_SILENCE, $2, NULL); } | scalar { $$ = $1; } | '`' backticks_expr '`' { $$ = zend_ast_create(ZEND_AST_SHELL_EXEC, $2); } | T_PRINT expr { $$ = zend_ast_create(ZEND_AST_PRINT, $2); } diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l index a367c2acb82da..feca51903a10b 100644 --- a/Zend/zend_language_scanner.l +++ b/Zend/zend_language_scanner.l @@ -1560,6 +1560,10 @@ NEWLINE ("\r"|"\n"|"\r\n") RETURN_TOKEN_WITH_IDENT(T_IMPLEMENTS); } +"@<" { + RETURN_TOKEN_WITH_IDENT(T_SILENCE_LIST); +} + "->" { yy_push_state(ST_LOOKING_FOR_PROPERTY); RETURN_TOKEN(T_OBJECT_OPERATOR); diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 86557b6e2bf11..1f768e8245ca8 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -7473,6 +7473,59 @@ ZEND_VM_HANDLER(58, ZEND_END_SILENCE, TMP, ANY) ZEND_VM_NEXT_OPCODE(); } +ZEND_VM_HANDLER(203, ZEND_SILENCE_CATCH, ANY, ANY) +{ + USE_OPLINE + + SAVE_OPLINE(); + + zend_exception_restore(); + + /* Came from class list virtual catch blocks */ + if (opline->extended_value == 2) { + if (EG(exception) == NULL) { + /* Free object (needed to not leak memory on @new) */ + if (Z_TYPE_P(EX_VAR(opline->result.var)) == IS_OBJECT) { + //OBJ_RELEASE(Z_OBJ_P(EX_VAR(opline->result.var))); + } + + /* Set value to NULL */ + if (opline->result_type & (IS_VAR | IS_TMP_VAR)) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + } else { + zend_rethrow_exception(execute_data); + HANDLE_EXCEPTION(); + } + } else if (EG(exception) && opline->extended_value != 2) { +#ifdef HAVE_DTRACE + if (DTRACE_EXCEPTION_CAUGHT_ENABLED()) { + DTRACE_EXCEPTION_CAUGHT((char *)EG(exception)->ce->name); + } +#endif /* HAVE_DTRACE */ + OBJ_RELEASE(EG(exception)); + EG(exception) = NULL; + + /* Free object (needed to not leak memory on @new) */ + if (Z_TYPE_P(EX_VAR(opline->result.var)) == IS_OBJECT) { + //OBJ_RELEASE(Z_OBJ_P(EX_VAR(opline->result.var))); + } + + /* Set value to NULL */ + if (opline->result_type & (IS_VAR | IS_TMP_VAR)) { + /* Make internal functions which set a return value early return false */ + if (UNEXPECTED(Z_TYPE_P(EX_VAR(opline->result.var)) != IS_UNDEF + && Z_TYPE_P(EX_VAR(opline->result.var)) <= IS_TRUE)) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + } else { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + } + } + + ZEND_VM_NEXT_OPCODE(); +} + ZEND_VM_COLD_CONST_HANDLER(152, ZEND_JMP_SET, CONST|TMP|VAR|CV, JMP_ADDR) { USE_OPLINE @@ -7918,7 +7971,10 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY) } } - cleanup_unfinished_calls(execute_data, throw_op_num); + /* Do not cleanup unfinished calls for SILENCE live range as it might still get executed */ + if (!is_in_silence_live_range(EX(func)->op_array, throw_op_num)) { + cleanup_unfinished_calls(execute_data, throw_op_num); + } if (throw_op->result_type & (IS_VAR | IS_TMP_VAR)) { switch (throw_op->opcode) { diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 13ba74433602f..2c4e721741231 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -2916,6 +2916,59 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEN ZEND_VM_NEXT_OPCODE(); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SILENCE_CATCH_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + SAVE_OPLINE(); + + zend_exception_restore(); + + /* Came from class list virtual catch blocks */ + if (opline->extended_value == 2) { + if (EG(exception) == NULL) { + /* Free object (needed to not leak memory on @new) */ + if (Z_TYPE_P(EX_VAR(opline->result.var)) == IS_OBJECT) { + //OBJ_RELEASE(Z_OBJ_P(EX_VAR(opline->result.var))); + } + + /* Set value to NULL */ + if (opline->result_type & (IS_VAR | IS_TMP_VAR)) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + } else { + zend_rethrow_exception(execute_data); + HANDLE_EXCEPTION(); + } + } else if (EG(exception) && opline->extended_value != 2) { +#ifdef HAVE_DTRACE + if (DTRACE_EXCEPTION_CAUGHT_ENABLED()) { + DTRACE_EXCEPTION_CAUGHT((char *)EG(exception)->ce->name); + } +#endif /* HAVE_DTRACE */ + OBJ_RELEASE(EG(exception)); + EG(exception) = NULL; + + /* Free object (needed to not leak memory on @new) */ + if (Z_TYPE_P(EX_VAR(opline->result.var)) == IS_OBJECT) { + //OBJ_RELEASE(Z_OBJ_P(EX_VAR(opline->result.var))); + } + + /* Set value to NULL */ + if (opline->result_type & (IS_VAR | IS_TMP_VAR)) { + /* Make internal functions which set a return value early return false */ + if (UNEXPECTED(Z_TYPE_P(EX_VAR(opline->result.var)) != IS_UNDEF + && Z_TYPE_P(EX_VAR(opline->result.var)) <= IS_TRUE)) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + } else { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + } + } + + ZEND_VM_NEXT_OPCODE(); +} + static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_EXT_STMT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -3117,7 +3170,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER( } } - cleanup_unfinished_calls(execute_data, throw_op_num); + /* Do not cleanup unfinished calls for SILENCE live range as it might still get executed */ + if (!is_in_silence_live_range(EX(func)->op_array, throw_op_num)) { + cleanup_unfinished_calls(execute_data, throw_op_num); + } if (throw_op->result_type & (IS_VAR | IS_TMP_VAR)) { switch (throw_op->opcode) { @@ -54753,6 +54809,7 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_LABEL, (void*)&&ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_LABEL, (void*)&&ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_LABEL, + (void*)&&ZEND_SILENCE_CATCH_SPEC_LABEL, (void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL, (void*)&&ZEND_JMP_FORWARD_SPEC_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -55969,6 +56026,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_BEGIN_SILENCE_SPEC) ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_SILENCE_CATCH_SPEC): + VM_TRACE(ZEND_SILENCE_CATCH_SPEC) + ZEND_SILENCE_CATCH_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_EXT_STMT_SPEC): VM_TRACE(ZEND_EXT_STMT_SPEC) ZEND_EXT_STMT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -62804,6 +62865,7 @@ void zend_vm_init(void) ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_HANDLER, ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED_HANDLER, ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED_HANDLER, + ZEND_SILENCE_CATCH_SPEC_HANDLER, ZEND_RECV_NOTYPE_SPEC_HANDLER, ZEND_JMP_FORWARD_SPEC_HANDLER, ZEND_NULL_HANDLER, @@ -63755,7 +63817,7 @@ void zend_vm_init(void) 1255, 1256 | SPEC_RULE_OP1, 1261 | SPEC_RULE_OP1, - 3448, + 3449, 1266 | SPEC_RULE_OP1, 1271 | SPEC_RULE_OP1, 1276 | SPEC_RULE_OP2, @@ -63913,59 +63975,59 @@ void zend_vm_init(void) 2542, 2543, 2544, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, - 3448, + 2545, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, + 3449, }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -64138,7 +64200,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 = 2547 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2548 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -64146,7 +64208,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 = 2572 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2573 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -64154,7 +64216,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2597 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2598 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -64165,17 +64227,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 = 2622 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2623 | 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 = 2647 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2648 | 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 = 2672 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2673 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -64186,17 +64248,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 = 2697 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2698 | 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 = 2722 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2723 | 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 = 2747 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2748 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -64207,14 +64269,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 = 2772 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2773 | 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 = 2847 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2848 | 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 = 3072 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3073 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -64225,14 +64287,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 = 2922 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2923 | 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 = 2997 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2998 | 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 = 3077 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3078 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -64243,12 +64305,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 = 2772 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2773 | 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 = 2847 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2848 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -64259,12 +64321,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 = 2922 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2923 | 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 = 2997 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2998 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -64272,12 +64334,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 = 3082 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3083 | 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 = 3157 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3158 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -64285,74 +64347,74 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3232 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3233 | 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 = 3307 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3308 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3394 | SPEC_RULE_OP1; + spec = 3395 | SPEC_RULE_OP1; } else if (op1_info == MAY_BE_DOUBLE) { - spec = 3399 | SPEC_RULE_OP1; + spec = 3400 | 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 = 3404 | SPEC_RULE_OP1; + spec = 3405 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3382 | SPEC_RULE_RETVAL; + spec = 3383 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3384 | SPEC_RULE_RETVAL; + spec = 3385 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3386 | SPEC_RULE_RETVAL; + spec = 3387 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3388 | SPEC_RULE_RETVAL; + spec = 3389 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3390; - } else if (op1_info == MAY_BE_LONG) { spec = 3391; + } else if (op1_info == MAY_BE_LONG) { + spec = 3392; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3392; - } else if (op1_info == MAY_BE_LONG) { spec = 3393; + } else if (op1_info == MAY_BE_LONG) { + spec = 3394; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2546; + spec = 2547; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2545; + spec = 2546; } 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 = 3444; + spec = 3445; } 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 = 3439 | SPEC_RULE_OP1; + spec = 3440 | 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 = 3446 | SPEC_RULE_RETVAL; + spec = 3447 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -64360,17 +64422,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 = 3409 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3410 | 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 = 3445; + spec = 3446; } break; case ZEND_SEND_VAR: if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3434 | SPEC_RULE_OP1; + spec = 3435 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 5f651ded1f35f..888ab46743c3e 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -1351,498 +1351,499 @@ _(2542, ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED) \ _(2543, ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED) \ _(2544, ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED) \ - _(2545, ZEND_RECV_NOTYPE_SPEC) \ - _(2546, ZEND_JMP_FORWARD_SPEC) \ - _(2552, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2553, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2545, ZEND_SILENCE_CATCH_SPEC) \ + _(2546, ZEND_RECV_NOTYPE_SPEC) \ + _(2547, ZEND_JMP_FORWARD_SPEC) \ + _(2553, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2554, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2556, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2557, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2558, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2555, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2557, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2558, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2559, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2561, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2567, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2568, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2560, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2562, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2568, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2569, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2571, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2577, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2578, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2570, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2572, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2578, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(2579, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2581, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2582, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2583, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2580, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2582, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2583, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(2584, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2586, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2592, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2593, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2585, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2587, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2593, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(2594, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2596, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2602, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2603, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2595, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2597, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2603, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2604, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2606, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2607, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2608, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2605, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2607, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2608, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2609, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2611, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2617, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2618, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2610, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2612, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2618, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2619, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2621, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2623, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2620, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2622, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2624, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2626, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2627, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2628, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2625, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2627, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2628, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2629, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2631, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2632, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2633, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2630, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2632, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2633, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2634, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2636, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2642, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2643, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2635, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2637, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2643, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2644, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2646, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2648, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2645, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2647, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2649, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2651, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2652, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2653, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2650, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2652, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2653, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(2654, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2656, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2657, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2658, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2655, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2657, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2658, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(2659, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2661, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2667, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2668, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2660, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2662, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2668, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(2669, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2671, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2673, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2670, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2672, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2674, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2676, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2677, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2678, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2675, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2677, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2678, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2679, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2681, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2682, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2683, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2680, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2682, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2683, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2684, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2686, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2692, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2693, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2685, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2687, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2693, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2694, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2696, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2702, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2703, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2695, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2697, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2703, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2704, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2706, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2707, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2708, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2705, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2707, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2708, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2709, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2711, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2717, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2718, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2710, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2712, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2718, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2719, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2721, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2727, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2728, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2720, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2722, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2728, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(2729, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2731, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2732, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2733, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2730, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2732, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2733, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(2734, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2736, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2742, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2743, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2735, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2737, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2743, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(2744, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2746, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2752, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2753, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2745, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2747, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2753, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2754, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2756, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2757, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2758, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2755, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2757, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2758, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2759, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2761, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2767, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2768, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2760, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2762, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2768, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2769, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2771, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2787, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2788, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2789, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2790, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2791, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2792, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2793, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2794, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2795, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2799, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2800, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2801, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2802, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2803, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2804, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2805, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2806, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2807, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2808, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2809, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2810, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2814, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2815, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2816, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2832, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2845, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2862, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2863, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2864, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2865, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2866, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2867, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2868, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2869, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2870, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2874, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2875, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2876, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2877, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2878, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2879, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2880, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2881, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2882, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2883, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2884, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2885, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2889, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2890, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2891, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2907, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2920, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2937, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2938, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2939, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2940, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2941, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2942, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2943, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2944, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2945, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2949, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2950, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2951, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2952, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2953, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2954, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2955, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2956, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2957, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2958, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2959, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2960, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2964, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2965, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2966, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2982, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3012, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3013, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3014, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3015, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3016, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3017, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3018, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3019, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3020, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3024, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3025, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3026, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3027, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3028, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3029, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3030, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3031, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3032, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3033, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3034, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3035, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3039, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3040, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3041, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3057, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3072, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3076, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3077, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3081, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3085, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3086, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3087, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3088, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3089, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3090, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3094, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3095, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3096, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3097, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3098, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3099, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3100, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3101, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3102, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3103, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3104, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3105, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3109, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3110, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3111, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3112, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3113, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3114, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3115, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3116, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3117, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3118, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3119, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3120, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3124, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3125, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3126, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3142, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3154, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3160, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3161, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3162, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3163, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3164, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3165, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3169, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3170, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3171, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3172, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3173, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3174, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3175, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3176, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3177, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3178, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3179, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3180, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3184, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3185, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3186, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3187, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3188, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3189, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3190, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3191, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3192, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3193, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3194, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3195, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3199, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3200, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3201, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3217, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3235, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3236, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3237, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3238, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3239, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3240, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3244, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3245, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3246, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3247, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3248, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3249, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3250, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3251, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3252, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3253, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3254, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3255, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3259, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3260, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3261, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3262, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3263, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3264, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3265, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3266, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3267, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3268, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3269, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3270, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3310, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3311, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3312, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3313, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3314, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3315, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3319, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3320, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3321, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3322, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3323, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3324, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3325, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3326, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3327, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3328, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3329, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3330, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3334, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3335, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3336, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3337, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3338, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3339, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3340, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3341, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3342, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3343, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3344, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3345, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3382, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3383, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3384, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3385, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3386, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3387, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3388, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3389, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3390, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3391, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3392, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3393, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3394, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ - _(3395, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(2770, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2772, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2788, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2789, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2790, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2791, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2792, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2793, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2794, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2795, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2796, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2800, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2801, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2802, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2803, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2804, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2805, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2806, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2807, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2808, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2809, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2810, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2811, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2815, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2816, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2817, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2845, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2863, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2864, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2865, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2866, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2867, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2868, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2869, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2870, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2871, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2875, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2876, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2877, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2878, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2879, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2880, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2881, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2882, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2883, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2884, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2885, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2886, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2890, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2891, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2892, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2920, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2938, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2939, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2940, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2941, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2942, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2943, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2944, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2945, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2946, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2950, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2951, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2952, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2953, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2954, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2955, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2956, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2957, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2958, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2959, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2960, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2961, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2965, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2966, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2967, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3013, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3014, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3015, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3016, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3017, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3018, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3019, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3020, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3021, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3025, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3026, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3027, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3028, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3029, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3030, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3031, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3032, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3033, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3034, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3035, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3036, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3040, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3041, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3042, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3073, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3077, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3078, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3082, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3086, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3087, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3088, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3089, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3090, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3091, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3095, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3096, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3097, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3098, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3099, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3100, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3101, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3102, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3103, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3104, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3105, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3106, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3110, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3111, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3112, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3113, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3114, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3115, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3116, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3117, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3118, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3119, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3120, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3121, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3125, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3126, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3127, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3161, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3162, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3163, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3164, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3165, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3166, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3170, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3171, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3172, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3173, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3174, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3175, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3176, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3177, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3178, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3179, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3180, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3181, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3185, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3186, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3187, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3188, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3189, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3190, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3191, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3192, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3193, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3194, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3195, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3196, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3200, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3201, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3202, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3236, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3237, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3238, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3239, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3240, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3241, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3245, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3246, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3247, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3248, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3249, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3250, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3251, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3252, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3253, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3254, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3255, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3256, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3260, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3261, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3262, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3263, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3264, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3265, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3266, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3267, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3268, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3269, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3270, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3271, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3277, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3311, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3312, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3313, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3314, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3315, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3316, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3320, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3321, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3322, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3323, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3324, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3325, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3326, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3327, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3328, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3329, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3330, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3331, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3335, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3336, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3337, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3338, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3339, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3340, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3341, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3342, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3343, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3344, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3345, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3346, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3352, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3383, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3384, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3385, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3386, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3387, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3388, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3389, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3390, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3391, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3392, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3393, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3394, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3395, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ _(3396, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3398, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3399, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(3400, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3397, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3399, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3400, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ _(3401, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3403, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3404, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(3405, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3402, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3404, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3405, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ _(3406, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3408, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3410, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3407, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3409, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ _(3411, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3413, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3414, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3415, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3412, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3414, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3415, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ _(3416, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3418, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3419, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3420, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3417, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3419, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3420, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ _(3421, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3423, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3429, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(3430, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3422, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3424, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3430, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ _(3431, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3433, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3436, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3438, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3441, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ - _(3443, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ - _(3444, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3445, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3446, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3447, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3447+1, ZEND_NULL) + _(3432, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3434, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3437, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3439, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3442, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ + _(3444, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ + _(3445, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3446, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3447, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3448, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3448+1, ZEND_NULL) diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index c3f5e9d427aa4..457341e6c4a4b 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -22,7 +22,7 @@ #include #include -static const char *zend_vm_opcodes_names[203] = { +static const char *zend_vm_opcodes_names[204] = { "ZEND_NOP", "ZEND_ADD", "ZEND_SUB", @@ -226,9 +226,10 @@ static const char *zend_vm_opcodes_names[203] = { "ZEND_FETCH_GLOBALS", "ZEND_VERIFY_NEVER_TYPE", "ZEND_CALLABLE_CONVERT", + "ZEND_SILENCE_CATCH", }; -static uint32_t zend_vm_opcodes_flags[203] = { +static uint32_t zend_vm_opcodes_flags[204] = { 0x00000000, 0x00000b0b, 0x00000b0b, @@ -432,6 +433,7 @@ static uint32_t zend_vm_opcodes_flags[203] = { 0x00000101, 0x00000101, 0x00000101, + 0x00000000, }; ZEND_API const char* ZEND_FASTCALL zend_get_opcode_name(zend_uchar opcode) { diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h index 165e914e1cd53..ccc0d6165d920 100644 --- a/Zend/zend_vm_opcodes.h +++ b/Zend/zend_vm_opcodes.h @@ -285,7 +285,8 @@ END_EXTERN_C() #define ZEND_FETCH_GLOBALS 200 #define ZEND_VERIFY_NEVER_TYPE 201 #define ZEND_CALLABLE_CONVERT 202 +#define ZEND_SILENCE_CATCH 203 -#define ZEND_VM_LAST_OPCODE 202 +#define ZEND_VM_LAST_OPCODE 203 #endif diff --git a/ext/tokenizer/tokenizer_data.c b/ext/tokenizer/tokenizer_data.c index a5adc67308485..1b1ff8af6ec84 100644 --- a/ext/tokenizer/tokenizer_data.c +++ b/ext/tokenizer/tokenizer_data.c @@ -171,6 +171,7 @@ void tokenizer_register_constants(INIT_FUNC_ARGS) { REGISTER_LONG_CONSTANT("T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG", T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG", T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_BAD_CHARACTER", T_BAD_CHARACTER, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("T_SILENCE_LIST", T_SILENCE_LIST, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_DOUBLE_COLON", T_PAAMAYIM_NEKUDOTAYIM, CONST_CS | CONST_PERSISTENT); } @@ -324,6 +325,7 @@ char *get_token_type_name(int token_type) case T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG: return "T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG"; case T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG: return "T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG"; case T_BAD_CHARACTER: return "T_BAD_CHARACTER"; + case T_SILENCE_LIST: return "T_SILENCE_LIST"; } return NULL; diff --git a/ext/zend_test/test.c b/ext/zend_test/test.c index e7a778e520fa5..4b4eb0ab4a0f5 100644 --- a/ext/zend_test/test.c +++ b/ext/zend_test/test.c @@ -430,6 +430,29 @@ static ZEND_FUNCTION(zend_test_parameter_with_attribute) ZEND_PARSE_PARAMETERS_END(); RETURN_LONG(1); + +/* Tests possibility to return a value different than null for internal functions + * being swallowed by the @ operator. */ +static ZEND_FUNCTION(zend_suppress_exception_internal_return_false) +{ + ZEND_PARSE_PARAMETERS_NONE(); + + RETVAL_FALSE; + zend_throw_error(NULL, "Shouldn't be seen"); +} +static ZEND_FUNCTION(zend_suppress_exception_internal_return_true) +{ + ZEND_PARSE_PARAMETERS_NONE(); + + RETVAL_TRUE; + zend_throw_error(NULL, "Shouldn't be seen"); +} +static ZEND_FUNCTION(zend_suppress_exception_internal_return_int) +{ + ZEND_PARSE_PARAMETERS_NONE(); + + RETVAL_LONG(20); + zend_throw_error(NULL, "Shouldn't be seen"); } static zend_object *zend_test_class_new(zend_class_entry *class_type) diff --git a/ext/zend_test/test.stub.php b/ext/zend_test/test.stub.php index 5dbd8596546d9..ea38a594c4f9b 100644 --- a/ext/zend_test/test.stub.php +++ b/ext/zend_test/test.stub.php @@ -141,6 +141,10 @@ function zend_call_method(object|string $obj_or_class, string $method, mixed $ar function zend_test_zend_ini_parse_quantity(string $str): int {} function zend_test_zend_ini_parse_uquantity(string $str): int {} + + function zend_suppress_exception_internal_return_false(): bool {} + function zend_suppress_exception_internal_return_true(): bool {} + function zend_suppress_exception_internal_return_int(): int {} } namespace ZendTestNS { diff --git a/ext/zend_test/test_arginfo.h b/ext/zend_test/test_arginfo.h index 186f813e5ddc8..eb7ac0c7f3df6 100644 --- a/ext/zend_test/test_arginfo.h +++ b/ext/zend_test/test_arginfo.h @@ -1,5 +1,5 @@ /* This is a generated file, edit the .stub.php file instead. - * Stub hash: 2c654cefda278094fa4cdc25b83ced269e83cadf */ + * Stub hash: e7426cc654e8da81538baab28f27a9916803a256 */ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zend_test_array_return, 0, 0, IS_ARRAY, 0) ZEND_END_ARG_INFO() @@ -91,12 +91,18 @@ ZEND_END_ARG_INFO() #define arginfo_zend_test_zend_ini_parse_uquantity arginfo_zend_test_zend_ini_parse_quantity -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_ZendTestNS2_ZendSubNS_namespaced_func, 0, 0, _IS_BOOL, 0) +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zend_suppress_exception_internal_return_false, 0, 0, _IS_BOOL, 0) ZEND_END_ARG_INFO() -ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class__ZendTestClass_is_object, 0, 0, IS_LONG, 0) +#define arginfo_zend_suppress_exception_internal_return_true arginfo_zend_suppress_exception_internal_return_false + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_zend_suppress_exception_internal_return_int, 0, 0, IS_LONG, 0) ZEND_END_ARG_INFO() +#define arginfo_ZendTestNS2_ZendSubNS_namespaced_func arginfo_zend_suppress_exception_internal_return_false + +#define arginfo_class__ZendTestClass_is_object arginfo_zend_suppress_exception_internal_return_int + #define arginfo_class__ZendTestClass___toString arginfo_zend_get_current_func_name ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class__ZendTestClass_returnsStatic, 0, 0, IS_STATIC, 0) @@ -108,7 +114,7 @@ ZEND_END_ARG_INFO() ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_class__ZendTestChildClass_returnsThrowable, 0, 0, Exception, 0) ZEND_END_ARG_INFO() -#define arginfo_class__ZendTestTrait_testMethod arginfo_ZendTestNS2_ZendSubNS_namespaced_func +#define arginfo_class__ZendTestTrait_testMethod arginfo_zend_suppress_exception_internal_return_false ZEND_BEGIN_ARG_INFO_EX(arginfo_class_ZendTestParameterAttribute___construct, 0, 0, 1) ZEND_ARG_TYPE_INFO(0, parameter, IS_STRING, 0) @@ -162,6 +168,9 @@ static ZEND_FUNCTION(zend_get_current_func_name); static ZEND_FUNCTION(zend_call_method); static ZEND_FUNCTION(zend_test_zend_ini_parse_quantity); static ZEND_FUNCTION(zend_test_zend_ini_parse_uquantity); +static ZEND_FUNCTION(zend_suppress_exception_internal_return_false); +static ZEND_FUNCTION(zend_suppress_exception_internal_return_true); +static ZEND_FUNCTION(zend_suppress_exception_internal_return_int); static ZEND_FUNCTION(namespaced_func); static ZEND_METHOD(_ZendTestClass, is_object); static ZEND_METHOD(_ZendTestClass, __toString); @@ -205,6 +214,9 @@ static const zend_function_entry ext_functions[] = { ZEND_FE(zend_call_method, arginfo_zend_call_method) ZEND_FE(zend_test_zend_ini_parse_quantity, arginfo_zend_test_zend_ini_parse_quantity) ZEND_FE(zend_test_zend_ini_parse_uquantity, arginfo_zend_test_zend_ini_parse_uquantity) + ZEND_FE(zend_suppress_exception_internal_return_false, arginfo_zend_suppress_exception_internal_return_false) + ZEND_FE(zend_suppress_exception_internal_return_true, arginfo_zend_suppress_exception_internal_return_true) + ZEND_FE(zend_suppress_exception_internal_return_int, arginfo_zend_suppress_exception_internal_return_int) ZEND_NS_FE("ZendTestNS2\\ZendSubNS", namespaced_func, arginfo_ZendTestNS2_ZendSubNS_namespaced_func) ZEND_FE_END }; diff --git a/ext/zend_test/tests/suppress_exception_internal_return_false.phpt b/ext/zend_test/tests/suppress_exception_internal_return_false.phpt new file mode 100644 index 0000000000000..57d85bf36197a --- /dev/null +++ b/ext/zend_test/tests/suppress_exception_internal_return_false.phpt @@ -0,0 +1,23 @@ +--TEST-- +Suppresion operator internal functions can return things other than null: false +--SKIPIF-- + +--FILE-- +getMessage(), \PHP_EOL; +} + +echo 'Done', PHP_EOL; +?> +--EXPECT-- +bool(false) +Error: Shouldn't be seen +Done diff --git a/ext/zend_test/tests/suppress_exception_internal_return_int.phpt b/ext/zend_test/tests/suppress_exception_internal_return_int.phpt new file mode 100644 index 0000000000000..f0d6bce201438 --- /dev/null +++ b/ext/zend_test/tests/suppress_exception_internal_return_int.phpt @@ -0,0 +1,25 @@ +--TEST-- +Suppresion operator internal functions can return things other than null: int +--SKIPIF-- + +--XFAIL-- +TBD if should return false, null, or int +--FILE-- +getMessage(), \PHP_EOL; +} + +echo 'Done', PHP_EOL; +?> +--EXPECT-- +int(20) +Error: Shouldn't be seen +Done diff --git a/ext/zend_test/tests/suppress_exception_internal_return_true.phpt b/ext/zend_test/tests/suppress_exception_internal_return_true.phpt new file mode 100644 index 0000000000000..a504fd42f4caa --- /dev/null +++ b/ext/zend_test/tests/suppress_exception_internal_return_true.phpt @@ -0,0 +1,25 @@ +--TEST-- +Suppresion operator internal functions can return things other than null: true +--SKIPIF-- + +--XFAIL-- +TBD if should return false, null, or true +--FILE-- +getMessage(), \PHP_EOL; +} + +echo 'Done', PHP_EOL; +?> +--EXPECT-- +bool(true) +Error: Shouldn't be seen +Done From 00eab9bb677bc6e01bf980ea5e83b9a5db6d4748 Mon Sep 17 00:00:00 2001 From: George Peter Banyard Date: Sat, 13 Feb 2021 05:34:39 +0000 Subject: [PATCH 03/13] SKIP OPCache test which currently hangs --- ext/opcache/tests/revalidate_path_01.phpt | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/ext/opcache/tests/revalidate_path_01.phpt b/ext/opcache/tests/revalidate_path_01.phpt index ff87e73b55441..9d3747d025a78 100644 --- a/ext/opcache/tests/revalidate_path_01.phpt +++ b/ext/opcache/tests/revalidate_path_01.phpt @@ -6,6 +6,10 @@ opcache.enable_cli=1 opcache.revalidate_path=1 --EXTENSIONS-- opcache +--SKIPIF-- + --CONFLICTS-- server --FILE-- From c721386944da34f9b61d714580301650dc6db656 Mon Sep 17 00:00:00 2001 From: George Peter Banyard Date: Sat, 6 Mar 2021 17:02:45 +0000 Subject: [PATCH 04/13] =?UTF-8?q?Use=20zend=5Fclear=5Fexception(=C3=A0=20A?= =?UTF-8?q?PI?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Zend/zend_vm_def.h | 3 +-- Zend/zend_vm_execute.h | 3 +-- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 1f768e8245ca8..d7528e58d2a30 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -7503,8 +7503,7 @@ ZEND_VM_HANDLER(203, ZEND_SILENCE_CATCH, ANY, ANY) DTRACE_EXCEPTION_CAUGHT((char *)EG(exception)->ce->name); } #endif /* HAVE_DTRACE */ - OBJ_RELEASE(EG(exception)); - EG(exception) = NULL; + zend_clear_exception(); /* Free object (needed to not leak memory on @new) */ if (Z_TYPE_P(EX_VAR(opline->result.var)) == IS_OBJECT) { diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 2c4e721741231..a77e054626f0f 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -2946,8 +2946,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SILENCE_CATCH_SPEC_HANDLER(ZEN DTRACE_EXCEPTION_CAUGHT((char *)EG(exception)->ce->name); } #endif /* HAVE_DTRACE */ - OBJ_RELEASE(EG(exception)); - EG(exception) = NULL; + zend_clear_exception(); /* Free object (needed to not leak memory on @new) */ if (Z_TYPE_P(EX_VAR(opline->result.var)) == IS_OBJECT) { From e44b8accd22d8cbc32e4b5845d1cf20951fa52fd Mon Sep 17 00:00:00 2001 From: George Peter Banyard Date: Sat, 6 Mar 2021 17:38:37 +0000 Subject: [PATCH 05/13] Comment for where to suppres trace generation for exceptoin --- Zend/zend_exceptions.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Zend/zend_exceptions.c b/Zend/zend_exceptions.c index 3934a3cef0717..cefe703a1df2a 100644 --- a/Zend/zend_exceptions.c +++ b/Zend/zend_exceptions.c @@ -252,6 +252,8 @@ static zend_object *zend_default_exception_new_ex(zend_class_entry *class_type, object_properties_init(object, class_type); + /* Only build backtraces when we are not in a SILENCE live range */ + // TODO Live SILENCE_EXCEPTION live range? if (EG(current_execute_data)) { zend_fetch_debug_backtrace(&trace, skip_top_traces, From 04938fe49481b60feb29d338693afd3e2128c018 Mon Sep 17 00:00:00 2001 From: George Peter Banyard Date: Sat, 6 Mar 2021 19:28:39 +0000 Subject: [PATCH 06/13] Only suppres instances of Exception and not Throwable by default --- .../listed_exceptions_can_suppress_Error.phpt | 19 ++++++++++++++++ .../silence_function_nested.phpt | 2 +- .../simple_silence_not_silence_Error.phpt | 22 +++++++++++++++++++ .../yield_from_silenced_non_iterable.phpt | 11 +++++++--- Zend/zend_vm_def.h | 16 ++++++++++---- Zend/zend_vm_execute.h | 16 ++++++++++---- 6 files changed, 74 insertions(+), 12 deletions(-) create mode 100644 Zend/tests/silence_operator/listed_exceptions_can_suppress_Error.phpt create mode 100644 Zend/tests/silence_operator/simple_silence_not_silence_Error.phpt diff --git a/Zend/tests/silence_operator/listed_exceptions_can_suppress_Error.phpt b/Zend/tests/silence_operator/listed_exceptions_can_suppress_Error.phpt new file mode 100644 index 0000000000000..ea745649229aa --- /dev/null +++ b/Zend/tests/silence_operator/listed_exceptions_can_suppress_Error.phpt @@ -0,0 +1,19 @@ +--TEST-- +Listing Error in silence throwable class list should suppress +--FILE-- +test1(); + +var_dump($var); + +echo "Done\n"; +?> +--EXPECT-- +NULL +Done diff --git a/Zend/tests/silence_operator/silence_function_nested.phpt b/Zend/tests/silence_operator/silence_function_nested.phpt index 19126bce3c3ab..cb1e8246c5764 100644 --- a/Zend/tests/silence_operator/silence_function_nested.phpt +++ b/Zend/tests/silence_operator/silence_function_nested.phpt @@ -13,7 +13,7 @@ function test2($a) { return test1(); } -$var = @test2(); +$var = @test2(1); var_dump($var); diff --git a/Zend/tests/silence_operator/simple_silence_not_silence_Error.phpt b/Zend/tests/silence_operator/simple_silence_not_silence_Error.phpt new file mode 100644 index 0000000000000..9205dce95ca1b --- /dev/null +++ b/Zend/tests/silence_operator/simple_silence_not_silence_Error.phpt @@ -0,0 +1,22 @@ +--TEST-- +Suppression operator must not suppres Error type Throwable errors +--FILE-- + +--EXPECTF-- +Fatal error: Uncaught Error in %s:4 +Stack trace: +#0 %s(8): test1() +#1 {main} + thrown in %s on line 4 diff --git a/Zend/tests/silence_operator/yield_from_silenced_non_iterable.phpt b/Zend/tests/silence_operator/yield_from_silenced_non_iterable.phpt index ad9f4b4935b34..1f74ccb4b1b05 100644 --- a/Zend/tests/silence_operator/yield_from_silenced_non_iterable.phpt +++ b/Zend/tests/silence_operator/yield_from_silenced_non_iterable.phpt @@ -9,6 +9,7 @@ function foo() { function generator() { yield 1; + /* This emits a Error type of throwable which is not suppressed */ @yield from foo(); yield 2; } @@ -19,7 +20,11 @@ foreach (generator() as $val) { echo "Done\n"; ?> ---EXPECT-- +--EXPECTF-- int(1) -int(2) -Done + +Fatal error: Uncaught Error: Can use "yield from" only with arrays and Traversables in %s:%d +Stack trace: +#0 %s(%d): generator() +#1 {main} + thrown in %s on line %d diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index d7528e58d2a30..f84d7921273b1 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -7479,8 +7479,6 @@ ZEND_VM_HANDLER(203, ZEND_SILENCE_CATCH, ANY, ANY) SAVE_OPLINE(); - zend_exception_restore(); - /* Came from class list virtual catch blocks */ if (opline->extended_value == 2) { if (EG(exception) == NULL) { @@ -7498,6 +7496,13 @@ ZEND_VM_HANDLER(203, ZEND_SILENCE_CATCH, ANY, ANY) HANDLE_EXCEPTION(); } } else if (EG(exception) && opline->extended_value != 2) { + ZEND_ASSERT(EG(exception)->ce); + /* Only suppress Exception or a subclass of, and NOT Error throwable errors */ + if (!instanceof_function(zend_ce_exception, EG(exception)->ce)) { + zend_rethrow_exception(execute_data); + HANDLE_EXCEPTION(); + } + #ifdef HAVE_DTRACE if (DTRACE_EXCEPTION_CAUGHT_ENABLED()) { DTRACE_EXCEPTION_CAUGHT((char *)EG(exception)->ce->name); @@ -7970,8 +7975,11 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY) } } - /* Do not cleanup unfinished calls for SILENCE live range as it might still get executed */ - if (!is_in_silence_live_range(EX(func)->op_array, throw_op_num)) { + /* Do not cleanup unfinished calls for SILENCE live range as it might still get executed + * However, this can only happen if the exception is an instance of Exception + * (Error never gets suppressed) */ + if (!is_in_silence_live_range(EX(func)->op_array, throw_op_num) + || !instanceof_function(zend_ce_exception, EG(exception)->ce)) { cleanup_unfinished_calls(execute_data, throw_op_num); } diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index a77e054626f0f..1b21cad8d137a 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -2922,8 +2922,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SILENCE_CATCH_SPEC_HANDLER(ZEN SAVE_OPLINE(); - zend_exception_restore(); - /* Came from class list virtual catch blocks */ if (opline->extended_value == 2) { if (EG(exception) == NULL) { @@ -2941,6 +2939,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SILENCE_CATCH_SPEC_HANDLER(ZEN HANDLE_EXCEPTION(); } } else if (EG(exception) && opline->extended_value != 2) { + ZEND_ASSERT(EG(exception)->ce); + /* Only suppress Exception or a subclass of, and NOT Error throwable errors */ + if (!instanceof_function(zend_ce_exception, EG(exception)->ce)) { + zend_rethrow_exception(execute_data); + HANDLE_EXCEPTION(); + } + #ifdef HAVE_DTRACE if (DTRACE_EXCEPTION_CAUGHT_ENABLED()) { DTRACE_EXCEPTION_CAUGHT((char *)EG(exception)->ce->name); @@ -3169,8 +3174,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER( } } - /* Do not cleanup unfinished calls for SILENCE live range as it might still get executed */ - if (!is_in_silence_live_range(EX(func)->op_array, throw_op_num)) { + /* Do not cleanup unfinished calls for SILENCE live range as it might still get executed + * However, this can only happen if the exception is an instance of Exception + * (Error never gets suppressed) */ + if (!is_in_silence_live_range(EX(func)->op_array, throw_op_num) + || !instanceof_function(zend_ce_exception, EG(exception)->ce)) { cleanup_unfinished_calls(execute_data, throw_op_num); } From 4087ca24baae6c4a7519dcf0d182da0bd553d087 Mon Sep 17 00:00:00 2001 From: George Peter Banyard Date: Sat, 6 Mar 2021 20:15:26 +0000 Subject: [PATCH 07/13] Do not suppress diagnostics when a class list is passed to silence Also fixes a bug where any return value from @ would be NULL --- ...it_diagnostic_when_silence_class_list.phpt | 20 +++++++++++++++++ ...al_diagnostic_when_silence_class_list.phpt | 20 +++++++++++++++++ Zend/zend_compile.c | 6 +++-- Zend/zend_vm_def.h | 22 +++++++++---------- Zend/zend_vm_execute.h | 22 +++++++++---------- 5 files changed, 66 insertions(+), 24 deletions(-) create mode 100644 Zend/tests/silence_operator/emit_diagnostic_when_silence_class_list.phpt create mode 100644 Zend/tests/silence_operator/emit_internal_diagnostic_when_silence_class_list.phpt diff --git a/Zend/tests/silence_operator/emit_diagnostic_when_silence_class_list.phpt b/Zend/tests/silence_operator/emit_diagnostic_when_silence_class_list.phpt new file mode 100644 index 0000000000000..09e378efa1f98 --- /dev/null +++ b/Zend/tests/silence_operator/emit_diagnostic_when_silence_class_list.phpt @@ -0,0 +1,20 @@ +--TEST-- +Diagnostics should still be emitted if a class list is passed to @, userland +--FILE-- +test(); + +var_dump($var); + +echo "Done\n"; +?> +--EXPECTF-- +Notice: Diagnostic message in %s on line %d +bool(true) +Done diff --git a/Zend/tests/silence_operator/emit_internal_diagnostic_when_silence_class_list.phpt b/Zend/tests/silence_operator/emit_internal_diagnostic_when_silence_class_list.phpt new file mode 100644 index 0000000000000..0816ecbddeac8 --- /dev/null +++ b/Zend/tests/silence_operator/emit_internal_diagnostic_when_silence_class_list.phpt @@ -0,0 +1,20 @@ +--TEST-- +Diagnostics should still be emitted if a class list is passed to @, internal +--FILE-- +test(); + +var_dump($var); + +echo "Done\n"; +?> +--EXPECTF-- +Warning: Undefined variable $a in %s on line %d +int(1) +Done diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 3721b58de3bff..9899b4c4206e2 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -9332,6 +9332,7 @@ static void zend_compile_silence(znode *result, zend_ast *ast) /* {{{ */ { zend_ast *expr_ast = ast->child[0]; znode silence_node; + zend_op *silence_start_op; zend_op *silence_catch_op; uint32_t try_catch_offset; uint32_t virtual_catch_op_num; @@ -9341,7 +9342,7 @@ static void zend_compile_silence(znode *result, zend_ast *ast) /* {{{ */ try_catch_offset = zend_add_try_element(get_next_op_number()); CG(context).try_catch_offset = try_catch_offset; - zend_emit_op_tmp(&silence_node, ZEND_BEGIN_SILENCE, NULL, NULL); + silence_start_op = zend_emit_op_tmp(&silence_node, ZEND_BEGIN_SILENCE, NULL, NULL); if (expr_ast->kind == ZEND_AST_VAR) { /* For @$var we need to force a FETCH instruction, otherwise the CV access will @@ -9368,7 +9369,8 @@ static void zend_compile_silence(znode *result, zend_ast *ast) /* {{{ */ zend_ast_list *classes = zend_ast_get_list(ast->child[1]); uint32_t opnum_catch = (uint32_t)-1; - /* Inform SILENCE_CATCH opcode that there is an exception class list */ + /* Inform SILENCE_START and SILENCE_CATCH opcode that there is an exception class list */ + silence_start_op->extended_value = 1; silence_catch_op->extended_value = 2; ZEND_ASSERT(classes->children > 0 && "Should have at least one class"); diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index f84d7921273b1..e3af7c1422f28 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -7434,6 +7434,11 @@ ZEND_VM_HANDLER(57, ZEND_BEGIN_SILENCE, ANY, ANY) ZVAL_LONG(EX_VAR(opline->result.var), EG(error_reporting)); + /* Do not suppress diagnostics when a class list is passed to @ */ + if (opline->extended_value == 1) { + ZEND_VM_NEXT_OPCODE(); + } + if (!E_HAS_ONLY_FATAL_ERRORS(EG(error_reporting))) { do { /* Do not silence fatal errors */ @@ -7481,20 +7486,15 @@ ZEND_VM_HANDLER(203, ZEND_SILENCE_CATCH, ANY, ANY) /* Came from class list virtual catch blocks */ if (opline->extended_value == 2) { - if (EG(exception) == NULL) { - /* Free object (needed to not leak memory on @new) */ - if (Z_TYPE_P(EX_VAR(opline->result.var)) == IS_OBJECT) { - //OBJ_RELEASE(Z_OBJ_P(EX_VAR(opline->result.var))); - } - - /* Set value to NULL */ - if (opline->result_type & (IS_VAR | IS_TMP_VAR)) { - ZVAL_NULL(EX_VAR(opline->result.var)); - } - } else { + if (EG(exception) != NULL) { zend_rethrow_exception(execute_data); HANDLE_EXCEPTION(); } + /* Result is UNDEF means an exception has been caught */ + if (opline->result_type & (IS_VAR | IS_TMP_VAR) + && Z_TYPE_P(EX_VAR(opline->result.var)) == IS_UNDEF) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } } else if (EG(exception) && opline->extended_value != 2) { ZEND_ASSERT(EG(exception)->ce); /* Only suppress Exception or a subclass of, and NOT Error throwable errors */ diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 1b21cad8d137a..925a9ec1af4e8 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -2888,6 +2888,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEN ZVAL_LONG(EX_VAR(opline->result.var), EG(error_reporting)); + /* Do not suppress diagnostics when a class list is passed to @ */ + if (opline->extended_value == 1) { + ZEND_VM_NEXT_OPCODE(); + } + if (!E_HAS_ONLY_FATAL_ERRORS(EG(error_reporting))) { do { /* Do not silence fatal errors */ @@ -2924,20 +2929,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SILENCE_CATCH_SPEC_HANDLER(ZEN /* Came from class list virtual catch blocks */ if (opline->extended_value == 2) { - if (EG(exception) == NULL) { - /* Free object (needed to not leak memory on @new) */ - if (Z_TYPE_P(EX_VAR(opline->result.var)) == IS_OBJECT) { - //OBJ_RELEASE(Z_OBJ_P(EX_VAR(opline->result.var))); - } - - /* Set value to NULL */ - if (opline->result_type & (IS_VAR | IS_TMP_VAR)) { - ZVAL_NULL(EX_VAR(opline->result.var)); - } - } else { + if (EG(exception) != NULL) { zend_rethrow_exception(execute_data); HANDLE_EXCEPTION(); } + /* Result is UNDEF means an exception has been caught */ + if (opline->result_type & (IS_VAR | IS_TMP_VAR) + && Z_TYPE_P(EX_VAR(opline->result.var)) == IS_UNDEF) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } } else if (EG(exception) && opline->extended_value != 2) { ZEND_ASSERT(EG(exception)->ce); /* Only suppress Exception or a subclass of, and NOT Error throwable errors */ From dcef1905cfbe3d0c64f2f7d671e51724b7bd7c05 Mon Sep 17 00:00:00 2001 From: George Peter Banyard Date: Thu, 11 Mar 2021 04:19:59 +0000 Subject: [PATCH 08/13] Try to figure out how to free arguments --- Zend/zend_vm_def.h | 67 ++++++++++++++++++++++++++++++++++++++++++ Zend/zend_vm_execute.h | 67 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 134 insertions(+) diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index e3af7c1422f28..6818fcd5a8c4c 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -7981,6 +7981,73 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY) if (!is_in_silence_live_range(EX(func)->op_array, throw_op_num) || !instanceof_function(zend_ce_exception, EG(exception)->ce)) { cleanup_unfinished_calls(execute_data, throw_op_num); + } else if (UNEXPECTED(EX(call))) { + zend_execute_data *call = EX(call); + zend_op *opline = EX(func)->op_array.opcodes + throw_op_num; + bool do_exit = false; + unsigned int level = 0; + + printf("Opcode %d\n", opline->opcode); + /* Decrement opline */ + opline--; + + do { + switch (opline->opcode) { + case ZEND_DO_FCALL: + case ZEND_DO_ICALL: + case ZEND_DO_UCALL: + case ZEND_DO_FCALL_BY_NAME: + level++; + break; + case ZEND_INIT_FCALL: + case ZEND_INIT_FCALL_BY_NAME: + case ZEND_INIT_NS_FCALL_BY_NAME: + case ZEND_INIT_DYNAMIC_CALL: + case ZEND_INIT_USER_CALL: + case ZEND_INIT_METHOD_CALL: + case ZEND_INIT_STATIC_METHOD_CALL: + case ZEND_NEW: + if (level == 0) { + ZEND_CALL_NUM_ARGS(call) = 0; + do_exit = true; + } + level--; + break; + case ZEND_SEND_VAL: + case ZEND_SEND_VAL_EX: + case ZEND_SEND_VAR: + case ZEND_SEND_VAR_EX: + case ZEND_SEND_FUNC_ARG: + case ZEND_SEND_REF: + case ZEND_SEND_VAR_NO_REF: + case ZEND_SEND_VAR_NO_REF_EX: + case ZEND_SEND_USER: + if (level == 0) { + /* For named args, the number of arguments is up to date. */ + if (opline->op2_type != IS_CONST) { + ZEND_CALL_NUM_ARGS(call) = opline->op2.num; + } + do_exit = true; + } + break; + case ZEND_SEND_ARRAY: + case ZEND_SEND_UNPACK: + case ZEND_CHECK_UNDEF_ARGS: + if (level == 0) { + do_exit = true; + } + break; + } + if (!do_exit) { + opline--; + } + } while (!do_exit); + + //zend_vm_stack_free_args(call); + //zend_vm_stack_free_extra_args(call); + //EX(call) = call->prev_execute_data; + //zend_vm_stack_free_call_frame(call); + //call = EX(call); } if (throw_op->result_type & (IS_VAR | IS_TMP_VAR)) { diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 925a9ec1af4e8..2ddaed7475238 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -3180,6 +3180,73 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER( if (!is_in_silence_live_range(EX(func)->op_array, throw_op_num) || !instanceof_function(zend_ce_exception, EG(exception)->ce)) { cleanup_unfinished_calls(execute_data, throw_op_num); + } else if (UNEXPECTED(EX(call))) { + zend_execute_data *call = EX(call); + zend_op *opline = EX(func)->op_array.opcodes + throw_op_num; + bool do_exit = false; + unsigned int level = 0; + + printf("Opcode %d\n", opline->opcode); + /* Decrement opline */ + opline--; + + do { + switch (opline->opcode) { + case ZEND_DO_FCALL: + case ZEND_DO_ICALL: + case ZEND_DO_UCALL: + case ZEND_DO_FCALL_BY_NAME: + level++; + break; + case ZEND_INIT_FCALL: + case ZEND_INIT_FCALL_BY_NAME: + case ZEND_INIT_NS_FCALL_BY_NAME: + case ZEND_INIT_DYNAMIC_CALL: + case ZEND_INIT_USER_CALL: + case ZEND_INIT_METHOD_CALL: + case ZEND_INIT_STATIC_METHOD_CALL: + case ZEND_NEW: + if (level == 0) { + ZEND_CALL_NUM_ARGS(call) = 0; + do_exit = true; + } + level--; + break; + case ZEND_SEND_VAL: + case ZEND_SEND_VAL_EX: + case ZEND_SEND_VAR: + case ZEND_SEND_VAR_EX: + case ZEND_SEND_FUNC_ARG: + case ZEND_SEND_REF: + case ZEND_SEND_VAR_NO_REF: + case ZEND_SEND_VAR_NO_REF_EX: + case ZEND_SEND_USER: + if (level == 0) { + /* For named args, the number of arguments is up to date. */ + if (opline->op2_type != IS_CONST) { + ZEND_CALL_NUM_ARGS(call) = opline->op2.num; + } + do_exit = true; + } + break; + case ZEND_SEND_ARRAY: + case ZEND_SEND_UNPACK: + case ZEND_CHECK_UNDEF_ARGS: + if (level == 0) { + do_exit = true; + } + break; + } + if (!do_exit) { + opline--; + } + } while (!do_exit); + + //zend_vm_stack_free_args(call); + //zend_vm_stack_free_extra_args(call); + //EX(call) = call->prev_execute_data; + //zend_vm_stack_free_call_frame(call); + //call = EX(call); } if (throw_op->result_type & (IS_VAR | IS_TMP_VAR)) { From 94a2904ae1a5b6f42c94a0038aa77db7fac19b6f Mon Sep 17 00:00:00 2001 From: George Peter Banyard Date: Thu, 11 Mar 2021 04:20:03 +0000 Subject: [PATCH 09/13] Revert "Try to figure out how to free arguments" This reverts commit 4cc48b35040bf462769f0ad75c521cf1705c2c74. --- Zend/zend_vm_def.h | 67 ------------------------------------------ Zend/zend_vm_execute.h | 67 ------------------------------------------ 2 files changed, 134 deletions(-) diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 6818fcd5a8c4c..e3af7c1422f28 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -7981,73 +7981,6 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY) if (!is_in_silence_live_range(EX(func)->op_array, throw_op_num) || !instanceof_function(zend_ce_exception, EG(exception)->ce)) { cleanup_unfinished_calls(execute_data, throw_op_num); - } else if (UNEXPECTED(EX(call))) { - zend_execute_data *call = EX(call); - zend_op *opline = EX(func)->op_array.opcodes + throw_op_num; - bool do_exit = false; - unsigned int level = 0; - - printf("Opcode %d\n", opline->opcode); - /* Decrement opline */ - opline--; - - do { - switch (opline->opcode) { - case ZEND_DO_FCALL: - case ZEND_DO_ICALL: - case ZEND_DO_UCALL: - case ZEND_DO_FCALL_BY_NAME: - level++; - break; - case ZEND_INIT_FCALL: - case ZEND_INIT_FCALL_BY_NAME: - case ZEND_INIT_NS_FCALL_BY_NAME: - case ZEND_INIT_DYNAMIC_CALL: - case ZEND_INIT_USER_CALL: - case ZEND_INIT_METHOD_CALL: - case ZEND_INIT_STATIC_METHOD_CALL: - case ZEND_NEW: - if (level == 0) { - ZEND_CALL_NUM_ARGS(call) = 0; - do_exit = true; - } - level--; - break; - case ZEND_SEND_VAL: - case ZEND_SEND_VAL_EX: - case ZEND_SEND_VAR: - case ZEND_SEND_VAR_EX: - case ZEND_SEND_FUNC_ARG: - case ZEND_SEND_REF: - case ZEND_SEND_VAR_NO_REF: - case ZEND_SEND_VAR_NO_REF_EX: - case ZEND_SEND_USER: - if (level == 0) { - /* For named args, the number of arguments is up to date. */ - if (opline->op2_type != IS_CONST) { - ZEND_CALL_NUM_ARGS(call) = opline->op2.num; - } - do_exit = true; - } - break; - case ZEND_SEND_ARRAY: - case ZEND_SEND_UNPACK: - case ZEND_CHECK_UNDEF_ARGS: - if (level == 0) { - do_exit = true; - } - break; - } - if (!do_exit) { - opline--; - } - } while (!do_exit); - - //zend_vm_stack_free_args(call); - //zend_vm_stack_free_extra_args(call); - //EX(call) = call->prev_execute_data; - //zend_vm_stack_free_call_frame(call); - //call = EX(call); } if (throw_op->result_type & (IS_VAR | IS_TMP_VAR)) { diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 2ddaed7475238..925a9ec1af4e8 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -3180,73 +3180,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER( if (!is_in_silence_live_range(EX(func)->op_array, throw_op_num) || !instanceof_function(zend_ce_exception, EG(exception)->ce)) { cleanup_unfinished_calls(execute_data, throw_op_num); - } else if (UNEXPECTED(EX(call))) { - zend_execute_data *call = EX(call); - zend_op *opline = EX(func)->op_array.opcodes + throw_op_num; - bool do_exit = false; - unsigned int level = 0; - - printf("Opcode %d\n", opline->opcode); - /* Decrement opline */ - opline--; - - do { - switch (opline->opcode) { - case ZEND_DO_FCALL: - case ZEND_DO_ICALL: - case ZEND_DO_UCALL: - case ZEND_DO_FCALL_BY_NAME: - level++; - break; - case ZEND_INIT_FCALL: - case ZEND_INIT_FCALL_BY_NAME: - case ZEND_INIT_NS_FCALL_BY_NAME: - case ZEND_INIT_DYNAMIC_CALL: - case ZEND_INIT_USER_CALL: - case ZEND_INIT_METHOD_CALL: - case ZEND_INIT_STATIC_METHOD_CALL: - case ZEND_NEW: - if (level == 0) { - ZEND_CALL_NUM_ARGS(call) = 0; - do_exit = true; - } - level--; - break; - case ZEND_SEND_VAL: - case ZEND_SEND_VAL_EX: - case ZEND_SEND_VAR: - case ZEND_SEND_VAR_EX: - case ZEND_SEND_FUNC_ARG: - case ZEND_SEND_REF: - case ZEND_SEND_VAR_NO_REF: - case ZEND_SEND_VAR_NO_REF_EX: - case ZEND_SEND_USER: - if (level == 0) { - /* For named args, the number of arguments is up to date. */ - if (opline->op2_type != IS_CONST) { - ZEND_CALL_NUM_ARGS(call) = opline->op2.num; - } - do_exit = true; - } - break; - case ZEND_SEND_ARRAY: - case ZEND_SEND_UNPACK: - case ZEND_CHECK_UNDEF_ARGS: - if (level == 0) { - do_exit = true; - } - break; - } - if (!do_exit) { - opline--; - } - } while (!do_exit); - - //zend_vm_stack_free_args(call); - //zend_vm_stack_free_extra_args(call); - //EX(call) = call->prev_execute_data; - //zend_vm_stack_free_call_frame(call); - //call = EX(call); } if (throw_op->result_type & (IS_VAR | IS_TMP_VAR)) { From 83fa045d5044be7b66c300064695018bc8383055 Mon Sep 17 00:00:00 2001 From: George Peter Banyard Date: Thu, 11 Mar 2021 04:40:17 +0000 Subject: [PATCH 10/13] Drop check for exception type and add tests --- .../internal_function_supp_arg_exception.phpt | 22 ++++++++++++++++ ...al_function_supp_arg_exception_listed.phpt | 22 ++++++++++++++++ .../user_function_supp_arg_exception.phpt | 26 +++++++++++++++++++ ...er_function_supp_arg_exception_listed.phpt | 26 +++++++++++++++++++ Zend/zend_vm_def.h | 3 +-- Zend/zend_vm_execute.h | 3 +-- 6 files changed, 98 insertions(+), 4 deletions(-) create mode 100644 Zend/tests/silence_operator/internal_function_supp_arg_exception.phpt create mode 100644 Zend/tests/silence_operator/internal_function_supp_arg_exception_listed.phpt create mode 100644 Zend/tests/silence_operator/user_function_supp_arg_exception.phpt create mode 100644 Zend/tests/silence_operator/user_function_supp_arg_exception_listed.phpt diff --git a/Zend/tests/silence_operator/internal_function_supp_arg_exception.phpt b/Zend/tests/silence_operator/internal_function_supp_arg_exception.phpt new file mode 100644 index 0000000000000..d4cb84b1f5d82 --- /dev/null +++ b/Zend/tests/silence_operator/internal_function_supp_arg_exception.phpt @@ -0,0 +1,22 @@ +--TEST-- +Silencing an internal function supplementary argument throwing an Exception +--FILE-- + +--EXPECTF-- +Fatal error: Uncaught ArgumentCountError: error_get_last() expects exactly 0 arguments, 1 given in %s:%d +Stack trace: +#0 %s(%d): error_get_last(NULL) +#1 {main} + thrown in %s on line %d diff --git a/Zend/tests/silence_operator/internal_function_supp_arg_exception_listed.phpt b/Zend/tests/silence_operator/internal_function_supp_arg_exception_listed.phpt new file mode 100644 index 0000000000000..44bcdf5833ffa --- /dev/null +++ b/Zend/tests/silence_operator/internal_function_supp_arg_exception_listed.phpt @@ -0,0 +1,22 @@ +--TEST-- +Listed silencing a internal function supplementary argument throwing an Exception +--FILE-- +foo()); + +var_dump($var); + +echo "Done\n"; +?> +--EXPECTF-- +Fatal error: Uncaught ArgumentCountError: error_get_last() expects exactly 0 arguments, 1 given in %s:%d +Stack trace: +#0 %s(%d): error_get_last(NULL) +#1 {main} + thrown in %s on line %d diff --git a/Zend/tests/silence_operator/user_function_supp_arg_exception.phpt b/Zend/tests/silence_operator/user_function_supp_arg_exception.phpt new file mode 100644 index 0000000000000..697bfe37be0d5 --- /dev/null +++ b/Zend/tests/silence_operator/user_function_supp_arg_exception.phpt @@ -0,0 +1,26 @@ +--TEST-- +Silencing a userland function supplementary argument throwing an Exception +--FILE-- + +--EXPECT-- +array(1) { + [0]=> + NULL +} +Done diff --git a/Zend/tests/silence_operator/user_function_supp_arg_exception_listed.phpt b/Zend/tests/silence_operator/user_function_supp_arg_exception_listed.phpt new file mode 100644 index 0000000000000..9de3def602d76 --- /dev/null +++ b/Zend/tests/silence_operator/user_function_supp_arg_exception_listed.phpt @@ -0,0 +1,26 @@ +--TEST-- +Listed silencing a userland function supplementary argument throwing an Exception +--FILE-- +foo()); + +var_dump($var); + +echo "Done\n"; +?> +--EXPECT-- +array(1) { + [0]=> + NULL +} +Done diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index e3af7c1422f28..37f7265e5afb0 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -7978,8 +7978,7 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY) /* Do not cleanup unfinished calls for SILENCE live range as it might still get executed * However, this can only happen if the exception is an instance of Exception * (Error never gets suppressed) */ - if (!is_in_silence_live_range(EX(func)->op_array, throw_op_num) - || !instanceof_function(zend_ce_exception, EG(exception)->ce)) { + if (!is_in_silence_live_range(EX(func)->op_array, throw_op_num)) { cleanup_unfinished_calls(execute_data, throw_op_num); } diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 925a9ec1af4e8..6b12adbd771c8 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -3177,8 +3177,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER( /* Do not cleanup unfinished calls for SILENCE live range as it might still get executed * However, this can only happen if the exception is an instance of Exception * (Error never gets suppressed) */ - if (!is_in_silence_live_range(EX(func)->op_array, throw_op_num) - || !instanceof_function(zend_ce_exception, EG(exception)->ce)) { + if (!is_in_silence_live_range(EX(func)->op_array, throw_op_num)) { cleanup_unfinished_calls(execute_data, throw_op_num); } From 9771000bf9feac93cb4c4dd77ede0675f9daf5e5 Mon Sep 17 00:00:00 2001 From: George Peter Banyard Date: Thu, 1 Apr 2021 15:29:25 +0100 Subject: [PATCH 11/13] Move live range check into cleanup_call --- Zend/zend_execute.c | 30 ++++++++++++++++++------------ Zend/zend_vm_def.h | 7 +------ Zend/zend_vm_execute.h | 7 +------ 3 files changed, 20 insertions(+), 24 deletions(-) diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index 7c566adfca586..10af1b8d29c0d 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -4077,9 +4077,27 @@ static zend_always_inline zend_generator *zend_get_running_generator(EXECUTE_DAT } /* }}} */ +/* TODO Can this be done using find_live_range? */ +static bool is_in_silence_live_range(const zend_op_array op_array, uint32_t op_num) { + for (int i = 0; i < op_array.last_live_range; i++) { + zend_live_range range = op_array.live_range[i]; + if (op_num >= range.start && op_num < range.end + && (range.var & ZEND_LIVE_MASK) == ZEND_LIVE_SILENCE) { + return true; + } + } + return false; +} + static void cleanup_unfinished_calls(zend_execute_data *execute_data, uint32_t op_num) /* {{{ */ { if (UNEXPECTED(EX(call))) { + /* Do not cleanup unfinished calls for SILENCE live range as it might still get executed + * However, this can only happen if the exception is an instance of Exception + * (Error never gets suppressed) */ + if (UNEXPECTED(is_in_silence_live_range(EX(func)->op_array, op_num))) { + return; + } zend_execute_data *call = EX(call); zend_op *opline = EX(func)->op_array.opcodes + op_num; int level; @@ -4222,18 +4240,6 @@ static const zend_live_range *find_live_range(const zend_op_array *op_array, uin } /* }}} */ -/* TODO Can this be done using find_live_range? */ -static bool is_in_silence_live_range(const zend_op_array op_array, uint32_t op_num) { - for (int i = 0; i < op_array.last_live_range; i++) { - zend_live_range range = op_array.live_range[i]; - if (op_num >= range.start && op_num < range.end - && (range.var & ZEND_LIVE_MASK) == ZEND_LIVE_SILENCE) { - return true; - } - } - return false; -} - static void cleanup_live_vars(zend_execute_data *execute_data, uint32_t op_num, uint32_t catch_op_num) /* {{{ */ { int i; diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 37f7265e5afb0..873721d1fd351 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -7975,12 +7975,7 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY) } } - /* Do not cleanup unfinished calls for SILENCE live range as it might still get executed - * However, this can only happen if the exception is an instance of Exception - * (Error never gets suppressed) */ - if (!is_in_silence_live_range(EX(func)->op_array, throw_op_num)) { - cleanup_unfinished_calls(execute_data, throw_op_num); - } + cleanup_unfinished_calls(execute_data, throw_op_num); if (throw_op->result_type & (IS_VAR | IS_TMP_VAR)) { switch (throw_op->opcode) { diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 6b12adbd771c8..0805fdf432ec0 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -3174,12 +3174,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER( } } - /* Do not cleanup unfinished calls for SILENCE live range as it might still get executed - * However, this can only happen if the exception is an instance of Exception - * (Error never gets suppressed) */ - if (!is_in_silence_live_range(EX(func)->op_array, throw_op_num)) { - cleanup_unfinished_calls(execute_data, throw_op_num); - } + cleanup_unfinished_calls(execute_data, throw_op_num); if (throw_op->result_type & (IS_VAR | IS_TMP_VAR)) { switch (throw_op->opcode) { From 7aa4afc35084becd23e5abe8cf29f3e3424d976c Mon Sep 17 00:00:00 2001 From: George Peter Banyard Date: Fri, 2 Apr 2021 00:41:46 +0100 Subject: [PATCH 12/13] Eh add check only for exceptions not Error --- Zend/zend_execute.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index 10af1b8d29c0d..1f906c57e410b 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -4095,7 +4095,8 @@ static void cleanup_unfinished_calls(zend_execute_data *execute_data, uint32_t o /* Do not cleanup unfinished calls for SILENCE live range as it might still get executed * However, this can only happen if the exception is an instance of Exception * (Error never gets suppressed) */ - if (UNEXPECTED(is_in_silence_live_range(EX(func)->op_array, op_num))) { + if (UNEXPECTED(is_in_silence_live_range(EX(func)->op_array, op_num) + && instanceof_function(zend_ce_exception, EG(exception)->ce))) { return; } zend_execute_data *call = EX(call); From c45e9183bc10da583d983faf090bd9933f75aaf7 Mon Sep 17 00:00:00 2001 From: George Peter Banyard Date: Wed, 22 Sep 2021 01:53:31 +0100 Subject: [PATCH 13/13] Some progress --- ...unction_supp_arg_exception_type_error.phpt | 26 +++++++++++++++++++ Zend/zend_execute.c | 8 ++++++ Zend/zend_vm_def.h | 7 +++++ Zend/zend_vm_execute.h | 7 +++++ ext/zend_test/test.c | 7 ++--- ...press_exception_internal_return_false.phpt | 6 ++--- ...uppress_exception_internal_return_int.phpt | 8 +++--- ...ppress_exception_internal_return_true.phpt | 8 +++--- 8 files changed, 61 insertions(+), 16 deletions(-) create mode 100644 Zend/tests/silence_operator/user_function_supp_arg_exception_type_error.phpt diff --git a/Zend/tests/silence_operator/user_function_supp_arg_exception_type_error.phpt b/Zend/tests/silence_operator/user_function_supp_arg_exception_type_error.phpt new file mode 100644 index 0000000000000..71d7151b1a4ae --- /dev/null +++ b/Zend/tests/silence_operator/user_function_supp_arg_exception_type_error.phpt @@ -0,0 +1,26 @@ +--TEST-- +Listed silencing a userland function supplementary argument throwing an Exception +--FILE-- +foo()); + var_dump($var); +} catch (\TypeError $e) { + echo $e->getMessage(), \PHP_EOL; +} + +echo "Done\n"; +?> +--EXPECTF-- +test1(): Argument #1 ($v) must be of type int, null given, called in %s on line %d +Done diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index 1f906c57e410b..e7e549fc3b1c9 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -4095,10 +4095,13 @@ static void cleanup_unfinished_calls(zend_execute_data *execute_data, uint32_t o /* Do not cleanup unfinished calls for SILENCE live range as it might still get executed * However, this can only happen if the exception is an instance of Exception * (Error never gets suppressed) */ + /* if (UNEXPECTED(is_in_silence_live_range(EX(func)->op_array, op_num) && instanceof_function(zend_ce_exception, EG(exception)->ce))) { return; } + */ + bool is_silence = is_in_silence_live_range(EX(func)->op_array, op_num) && instanceof_function(zend_ce_exception, EG(exception)->ce); zend_execute_data *call = EX(call); zend_op *opline = EX(func)->op_array.opcodes + op_num; int level; @@ -4170,9 +4173,14 @@ static void cleanup_unfinished_calls(zend_execute_data *execute_data, uint32_t o } break; } + if (!do_exit) { opline--; } + /* If this a silence range we should only release the last arg */ + if (is_silence) { + return; + } } while (!do_exit); if (call->prev_execute_data) { /* skip current call region */ diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 873721d1fd351..9faa834bd102d 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -7518,12 +7518,19 @@ ZEND_VM_HANDLER(203, ZEND_SILENCE_CATCH, ANY, ANY) /* Set value to NULL */ if (opline->result_type & (IS_VAR | IS_TMP_VAR)) { /* Make internal functions which set a return value early return false */ + /* if (UNEXPECTED(Z_TYPE_P(EX_VAR(opline->result.var)) != IS_UNDEF && Z_TYPE_P(EX_VAR(opline->result.var)) <= IS_TRUE)) { ZVAL_FALSE(EX_VAR(opline->result.var)); } else { ZVAL_NULL(EX_VAR(opline->result.var)); } + */ + + /* Set return value to null, except when an internal function has set a return value */ + if (EXPECTED(Z_TYPE_P(EX_VAR(opline->result.var)) == IS_UNDEF)) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } } } diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 0805fdf432ec0..8b46a5c5ae1c4 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -2961,12 +2961,19 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SILENCE_CATCH_SPEC_HANDLER(ZEN /* Set value to NULL */ if (opline->result_type & (IS_VAR | IS_TMP_VAR)) { /* Make internal functions which set a return value early return false */ + /* if (UNEXPECTED(Z_TYPE_P(EX_VAR(opline->result.var)) != IS_UNDEF && Z_TYPE_P(EX_VAR(opline->result.var)) <= IS_TRUE)) { ZVAL_FALSE(EX_VAR(opline->result.var)); } else { ZVAL_NULL(EX_VAR(opline->result.var)); } + */ + + /* Set return value to null, except when an internal function has set a return value */ + if (EXPECTED(Z_TYPE_P(EX_VAR(opline->result.var)) == IS_UNDEF)) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } } } diff --git a/ext/zend_test/test.c b/ext/zend_test/test.c index 4b4eb0ab4a0f5..f30917edc9ba2 100644 --- a/ext/zend_test/test.c +++ b/ext/zend_test/test.c @@ -29,6 +29,7 @@ #include "zend_interfaces.h" #include "zend_weakrefs.h" #include "Zend/Optimizer/zend_optimizer.h" +#include "zend_exceptions.h" #include "test_arginfo.h" ZEND_DECLARE_MODULE_GLOBALS(zend_test) @@ -438,21 +439,21 @@ static ZEND_FUNCTION(zend_suppress_exception_internal_return_false) ZEND_PARSE_PARAMETERS_NONE(); RETVAL_FALSE; - zend_throw_error(NULL, "Shouldn't be seen"); + zend_throw_exception(NULL, "Shouldn't be seen", 0); } static ZEND_FUNCTION(zend_suppress_exception_internal_return_true) { ZEND_PARSE_PARAMETERS_NONE(); RETVAL_TRUE; - zend_throw_error(NULL, "Shouldn't be seen"); + zend_throw_exception(NULL, "Shouldn't be seen", 0); } static ZEND_FUNCTION(zend_suppress_exception_internal_return_int) { ZEND_PARSE_PARAMETERS_NONE(); RETVAL_LONG(20); - zend_throw_error(NULL, "Shouldn't be seen"); + zend_throw_exception(NULL, "Shouldn't be seen", 0); } static zend_object *zend_test_class_new(zend_class_entry *class_type) diff --git a/ext/zend_test/tests/suppress_exception_internal_return_false.phpt b/ext/zend_test/tests/suppress_exception_internal_return_false.phpt index 57d85bf36197a..e20b6ae086a97 100644 --- a/ext/zend_test/tests/suppress_exception_internal_return_false.phpt +++ b/ext/zend_test/tests/suppress_exception_internal_return_false.phpt @@ -1,7 +1,7 @@ --TEST-- Suppresion operator internal functions can return things other than null: false ---SKIPIF-- - +--EXTENSIONS-- +zend_test --FILE-- --EXPECT-- bool(false) -Error: Shouldn't be seen +Exception: Shouldn't be seen Done diff --git a/ext/zend_test/tests/suppress_exception_internal_return_int.phpt b/ext/zend_test/tests/suppress_exception_internal_return_int.phpt index f0d6bce201438..3d60b616feee8 100644 --- a/ext/zend_test/tests/suppress_exception_internal_return_int.phpt +++ b/ext/zend_test/tests/suppress_exception_internal_return_int.phpt @@ -1,9 +1,7 @@ --TEST-- Suppresion operator internal functions can return things other than null: int ---SKIPIF-- - ---XFAIL-- -TBD if should return false, null, or int +--EXTENSIONS-- +zend_test --FILE-- --EXPECT-- int(20) -Error: Shouldn't be seen +Exception: Shouldn't be seen Done diff --git a/ext/zend_test/tests/suppress_exception_internal_return_true.phpt b/ext/zend_test/tests/suppress_exception_internal_return_true.phpt index a504fd42f4caa..0aea07d7448d0 100644 --- a/ext/zend_test/tests/suppress_exception_internal_return_true.phpt +++ b/ext/zend_test/tests/suppress_exception_internal_return_true.phpt @@ -1,9 +1,7 @@ --TEST-- Suppresion operator internal functions can return things other than null: true ---SKIPIF-- - ---XFAIL-- -TBD if should return false, null, or true +--EXTENSIONS-- +zend_test --FILE-- --EXPECT-- bool(true) -Error: Shouldn't be seen +Exception: Shouldn't be seen Done