From b45c51b6ac3aec89233d84f5e2b1ea04817f8e21 Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Thu, 9 Apr 2020 22:36:37 +0200 Subject: [PATCH 01/14] Implement match expression --- Zend/tests/match/001.phpt | 36 + Zend/tests/match/002.phpt | 19 + Zend/tests/match/003.phpt | 24 + Zend/tests/match/004.phpt | 31 + Zend/tests/match/005.phpt | 12 + Zend/tests/match/006.phpt | 13 + Zend/tests/match/007.phpt | 26 + Zend/tests/match/008.phpt | 25 + Zend/tests/match/009.phpt | 22 + Zend/tests/match/011.phpt | 19 + Zend/tests/match/012.phpt | 36 + Zend/tests/match/017.phpt | 92 ++ Zend/tests/match/023.phpt | 20 + Zend/tests/match/024.phpt | 19 + Zend/tests/match/027.phpt | 36 + Zend/tests/match/028.phpt | 36 + Zend/tests/match/029.phpt | 22 + Zend/tests/match/030.phpt | 22 + Zend/tests/match/037.phpt | 68 ++ Zend/tests/match/038.phpt | 15 + Zend/tests/match/039.phpt | 61 ++ Zend/tests/match/040.phpt | 44 + Zend/tests/match/041.phpt | 33 + Zend/tests/match/042.phpt | 14 + Zend/zend_ast.c | 20 + Zend/zend_ast.h | 3 + Zend/zend_compile.c | 243 +++++- Zend/zend_exceptions.c | 5 + Zend/zend_exceptions.h | 1 + Zend/zend_language_parser.y | 37 +- Zend/zend_language_scanner.l | 4 + Zend/zend_opcode.c | 4 + Zend/zend_vm_def.h | 52 ++ Zend/zend_vm_execute.h | 376 +++++++- Zend/zend_vm_handlers.h | 810 +++++++++--------- Zend/zend_vm_opcodes.c | 8 +- Zend/zend_vm_opcodes.h | 4 +- ext/opcache/Optimizer/block_pass.c | 7 + ext/opcache/Optimizer/dce.c | 4 +- ext/opcache/Optimizer/dfa_pass.c | 44 +- ext/opcache/Optimizer/pass1.c | 1 + ext/opcache/Optimizer/sccp.c | 41 +- ext/opcache/Optimizer/zend_cfg.c | 8 +- ext/opcache/Optimizer/zend_dump.c | 6 +- ext/opcache/Optimizer/zend_inference.c | 4 + ext/opcache/Optimizer/zend_optimizer.c | 25 +- ext/opcache/jit/zend_jit.c | 5 +- ext/opcache/jit/zend_jit_trace.c | 2 + ext/opcache/jit/zend_jit_x86.dasc | 7 + ext/opcache/tests/match/001.phpt | 75 ++ ext/opcache/tests/match/002.phpt | 57 ++ ext/opcache/tests/match/003.phpt | 74 ++ ext/opcache/tests/match/004.phpt | 93 ++ ext/opcache/zend_file_cache.c | 1 + ext/opcache/zend_persist.c | 1 + .../tests/file/fnmatch_variation.phpt | 10 +- ext/tokenizer/tokenizer_data.c | 22 +- 57 files changed, 2277 insertions(+), 522 deletions(-) create mode 100644 Zend/tests/match/001.phpt create mode 100644 Zend/tests/match/002.phpt create mode 100644 Zend/tests/match/003.phpt create mode 100644 Zend/tests/match/004.phpt create mode 100644 Zend/tests/match/005.phpt create mode 100644 Zend/tests/match/006.phpt create mode 100644 Zend/tests/match/007.phpt create mode 100644 Zend/tests/match/008.phpt create mode 100644 Zend/tests/match/009.phpt create mode 100644 Zend/tests/match/011.phpt create mode 100644 Zend/tests/match/012.phpt create mode 100644 Zend/tests/match/017.phpt create mode 100644 Zend/tests/match/023.phpt create mode 100644 Zend/tests/match/024.phpt create mode 100644 Zend/tests/match/027.phpt create mode 100644 Zend/tests/match/028.phpt create mode 100644 Zend/tests/match/029.phpt create mode 100644 Zend/tests/match/030.phpt create mode 100644 Zend/tests/match/037.phpt create mode 100644 Zend/tests/match/038.phpt create mode 100644 Zend/tests/match/039.phpt create mode 100644 Zend/tests/match/040.phpt create mode 100644 Zend/tests/match/041.phpt create mode 100644 Zend/tests/match/042.phpt create mode 100644 ext/opcache/tests/match/001.phpt create mode 100644 ext/opcache/tests/match/002.phpt create mode 100644 ext/opcache/tests/match/003.phpt create mode 100644 ext/opcache/tests/match/004.phpt diff --git a/Zend/tests/match/001.phpt b/Zend/tests/match/001.phpt new file mode 100644 index 0000000000000..9d338c1b423a2 --- /dev/null +++ b/Zend/tests/match/001.phpt @@ -0,0 +1,36 @@ +--TEST-- +Basic match expression functionality test +--FILE-- + 'Zero', + 1 => 'One', + 2 => 'Two', + 3 => 'Three', + 4 => 'Four', + 5 => 'Five', + 6 => 'Six', + 7 => 'Seven', + 8 => 'Eight', + 9 => 'Nine', + }; +} + +for ($i = 0; $i <= 9; $i++) { + print wordify($i) . "\n"; +} + +?> +--EXPECT-- +Zero +One +Two +Three +Four +Five +Six +Seven +Eight +Nine diff --git a/Zend/tests/match/002.phpt b/Zend/tests/match/002.phpt new file mode 100644 index 0000000000000..ad087c59265d2 --- /dev/null +++ b/Zend/tests/match/002.phpt @@ -0,0 +1,19 @@ +--TEST-- +Match expression omit trailing comma +--FILE-- + "true\n", + false => "false\n" + }; +} + +print_bool(true); +print_bool(false); + +?> +--EXPECT-- +true +false diff --git a/Zend/tests/match/003.phpt b/Zend/tests/match/003.phpt new file mode 100644 index 0000000000000..550d2277d615b --- /dev/null +++ b/Zend/tests/match/003.phpt @@ -0,0 +1,24 @@ +--TEST-- +Match expression default case +--FILE-- + 1, + 2 => 2, + default => 'default', + }; +} + +echo get_value(0) . "\n"; +echo get_value(1) . "\n"; +echo get_value(2) . "\n"; +echo get_value(3) . "\n"; + +?> +--EXPECT-- +default +1 +2 +default diff --git a/Zend/tests/match/004.phpt b/Zend/tests/match/004.phpt new file mode 100644 index 0000000000000..2f8717f74ea05 --- /dev/null +++ b/Zend/tests/match/004.phpt @@ -0,0 +1,31 @@ +--TEST-- +Match expression with true as expression +--FILE-- += 50 => '50+', + $i >= 40 => '40-50', + $i >= 30 => '30-40', + $i >= 20 => '20-30', + $i >= 10 => '10-20', + default => '0-10', + }; +} + +echo get_range(22) . "\n"; +echo get_range(0) . "\n"; +echo get_range(59) . "\n"; +echo get_range(13) . "\n"; +echo get_range(39) . "\n"; +echo get_range(40) . "\n"; + +?> +--EXPECT-- +20-30 +0-10 +50+ +10-20 +30-40 +40-50 diff --git a/Zend/tests/match/005.phpt b/Zend/tests/match/005.phpt new file mode 100644 index 0000000000000..cc72739f432bf --- /dev/null +++ b/Zend/tests/match/005.phpt @@ -0,0 +1,12 @@ +--TEST-- +Match expression discarding result +--FILE-- + print "Executed\n", +}; + +?> +--EXPECT-- +Executed diff --git a/Zend/tests/match/006.phpt b/Zend/tests/match/006.phpt new file mode 100644 index 0000000000000..63d8056143876 --- /dev/null +++ b/Zend/tests/match/006.phpt @@ -0,0 +1,13 @@ +--TEST-- +Match expression with no cases +--FILE-- + +--EXPECTF-- +Fatal error: Uncaught UnhandledMatchError in %s +Stack trace: +#0 {main} + thrown in %s on line %d diff --git a/Zend/tests/match/007.phpt b/Zend/tests/match/007.phpt new file mode 100644 index 0000000000000..35095975a9c50 --- /dev/null +++ b/Zend/tests/match/007.phpt @@ -0,0 +1,26 @@ +--TEST-- +Match expression exception on unhandled case +--FILE-- + 1, + 2 => 2, + }; +} + +echo get_value(1) . "\n"; +echo get_value(2) . "\n"; +echo get_value(3) . "\n"; + +?> +--EXPECTF-- +1 +2 + +Fatal error: Uncaught UnhandledMatchError in %s +Stack trace: +#0 %s: get_value(3) +#1 {main} + thrown in %s on line %d diff --git a/Zend/tests/match/008.phpt b/Zend/tests/match/008.phpt new file mode 100644 index 0000000000000..db91d80b87110 --- /dev/null +++ b/Zend/tests/match/008.phpt @@ -0,0 +1,25 @@ +--TEST-- +Match expression multiple conditions per case +--FILE-- + false, + 2, 3, 4, 5, 6 => true, + }; +} + +for ($i = 1; $i <= 7; $i++) { + var_dump(is_working_day($i)); +} + +?> +--EXPECT-- +bool(false) +bool(true) +bool(true) +bool(true) +bool(true) +bool(true) +bool(false) diff --git a/Zend/tests/match/009.phpt b/Zend/tests/match/009.phpt new file mode 100644 index 0000000000000..32153e745342b --- /dev/null +++ b/Zend/tests/match/009.phpt @@ -0,0 +1,22 @@ +--TEST-- +Pretty printing for match expression +--FILE-- + false, + 'baz' => 'a', + default => 'b', + }; +})()); + +?> +--EXPECTF-- +Warning: assert(): assert(function () { + match ('foo') { + 'foo', 'bar' => false, + 'baz' => 'a', + default => 'b', + }; +}()) failed in %s on line %d diff --git a/Zend/tests/match/011.phpt b/Zend/tests/match/011.phpt new file mode 100644 index 0000000000000..7af3ead5dad2d --- /dev/null +++ b/Zend/tests/match/011.phpt @@ -0,0 +1,19 @@ +--TEST-- +Implicit break in match expression +--FILE-- + dump_and_return('foo'), + 'bar' => dump_and_return('bar'), +}); + +?> +--EXPECTF-- +string(3) "foo" +string(3) "foo" diff --git a/Zend/tests/match/012.phpt b/Zend/tests/match/012.phpt new file mode 100644 index 0000000000000..c75fc73de87ad --- /dev/null +++ b/Zend/tests/match/012.phpt @@ -0,0 +1,36 @@ +--TEST-- +Strict comparison in match expression +--FILE-- + wrong(), + false => wrong(), + 0.0 => wrong(), + [] => wrong(), + '' => wrong(), + 0 => 'int', +}); + +function get_value() { + return 0; +} + +var_dump(match (get_value()) { + null => wrong(), + false => wrong(), + 0.0 => wrong(), + [] => wrong(), + '' => wrong(), + 0 => 'int', + default => 'default', +}); + +?> +--EXPECT-- +string(3) "int" +string(3) "int" diff --git a/Zend/tests/match/017.phpt b/Zend/tests/match/017.phpt new file mode 100644 index 0000000000000..622f7bb165105 --- /dev/null +++ b/Zend/tests/match/017.phpt @@ -0,0 +1,92 @@ +--TEST-- +Test strict comparison with match expression jump table +--FILE-- + wrong(), + 1 => wrong(), + 2 => wrong(), + 3 => wrong(), + 4 => wrong(), + 5 => wrong(), + 6 => wrong(), + 7 => wrong(), + 8 => wrong(), + 9 => wrong(), + default => 'Not matched', + }; +} + +foreach (range(0, 9) as $int) { + var_dump((string) $int); + var_dump(test_int((string) $int)); +} + +function test_string($int) { + return match ($int) { + '0' => wrong(), + '1' => wrong(), + '2' => wrong(), + '3' => wrong(), + '4' => wrong(), + '5' => wrong(), + '6' => wrong(), + '7' => wrong(), + '8' => wrong(), + '9' => wrong(), + default => 'Not matched', + }; +} + +foreach (range(0, 9) as $int) { + var_dump($int); + var_dump(test_string($int)); +} + +--EXPECT-- +string(1) "0" +string(11) "Not matched" +string(1) "1" +string(11) "Not matched" +string(1) "2" +string(11) "Not matched" +string(1) "3" +string(11) "Not matched" +string(1) "4" +string(11) "Not matched" +string(1) "5" +string(11) "Not matched" +string(1) "6" +string(11) "Not matched" +string(1) "7" +string(11) "Not matched" +string(1) "8" +string(11) "Not matched" +string(1) "9" +string(11) "Not matched" +int(0) +string(11) "Not matched" +int(1) +string(11) "Not matched" +int(2) +string(11) "Not matched" +int(3) +string(11) "Not matched" +int(4) +string(11) "Not matched" +int(5) +string(11) "Not matched" +int(6) +string(11) "Not matched" +int(7) +string(11) "Not matched" +int(8) +string(11) "Not matched" +int(9) +string(11) "Not matched" diff --git a/Zend/tests/match/023.phpt b/Zend/tests/match/023.phpt new file mode 100644 index 0000000000000..f82ece2873ae3 --- /dev/null +++ b/Zend/tests/match/023.phpt @@ -0,0 +1,20 @@ +--TEST-- +Test match strict comparison with true expression +--FILE-- + wrong(), + ['truthy'] => wrong(), + new stdClass() => wrong(), + 1 => wrong(), + 1.0 => wrong(), + true => "true\n", +}; + +--EXPECT-- +true diff --git a/Zend/tests/match/024.phpt b/Zend/tests/match/024.phpt new file mode 100644 index 0000000000000..020bb3764b9d8 --- /dev/null +++ b/Zend/tests/match/024.phpt @@ -0,0 +1,19 @@ +--TEST-- +Test match strict comparison with false expression +--FILE-- + wrong(), + [] => wrong(), + 0 => wrong(), + 0.0 => wrong(), + false => "false\n", +}; + +--EXPECT-- +false diff --git a/Zend/tests/match/027.phpt b/Zend/tests/match/027.phpt new file mode 100644 index 0000000000000..2f1ce21984f32 --- /dev/null +++ b/Zend/tests/match/027.phpt @@ -0,0 +1,36 @@ +--TEST-- +Test result of match cannot be modified by reference +--FILE-- + $i }); + echo "i is $i\n"; + $j = 1; + Test::usesRef(match(true) { true => $i }); + echo "j is $j\n"; +} +main(); + +--EXPECTF-- +usesValue 0 +i is 0 + +Fatal error: Uncaught Error: Cannot pass parameter 1 by reference in %s027.php:20 +Stack trace: +#0 %s027.php(23): main() +#1 {main} + thrown in %s027.php on line 20 diff --git a/Zend/tests/match/028.phpt b/Zend/tests/match/028.phpt new file mode 100644 index 0000000000000..8cad03c099eef --- /dev/null +++ b/Zend/tests/match/028.phpt @@ -0,0 +1,36 @@ +--TEST-- +Test result of match cannot be modified by reference +--FILE-- + $i }); + Test::usesValue(match($i) { 42 => $i }); + var_dump($i); + Test::usesRef(match(true) { true => $i }); + var_dump($i); +} + +try { + main(42); +} catch (Error $e) { + printf("Caught %s\n", $e->getMessage()); +} + +--EXPECT-- +usesValue 42 +usesValue 42 +int(42) +Caught Cannot pass parameter 1 by reference diff --git a/Zend/tests/match/029.phpt b/Zend/tests/match/029.phpt new file mode 100644 index 0000000000000..7ebcdedc70e24 --- /dev/null +++ b/Zend/tests/match/029.phpt @@ -0,0 +1,22 @@ +--TEST-- +Test long match with undefined variable +--FILE-- + "This should not get printed with or without opcache\n", + 1, 2, 3, 4, 5 => "Also should not be printed\n", +}; + +echo "unreachable\n"; + +--EXPECTF-- +Fatal error: Uncaught Exception: Custom error handler: Undefined variable $undefVar in %s029.php:4 +Stack trace: +#0 %s029.php(7): {closure}(%d, 'Undefined varia...', '%s', %d) +#1 {main} + thrown in %s029.php on line 4 diff --git a/Zend/tests/match/030.phpt b/Zend/tests/match/030.phpt new file mode 100644 index 0000000000000..1271d72e422d1 --- /dev/null +++ b/Zend/tests/match/030.phpt @@ -0,0 +1,22 @@ +--TEST-- +Test string match with undefined variable +--FILE-- + "This should not get printed with or without opcache\n", + '1', '2', '3', '4', '5' => "Also should not be printed\n", +}; + +echo "unreachable\n"; + +--EXPECTF-- +Fatal error: Uncaught Exception: Custom error handler: Undefined variable $undefVar in %s030.php:4 +Stack trace: +#0 %s030.php(7): {closure}(%d, 'Undefined varia...', '%s', %d) +#1 {main} + thrown in %s030.php on line 4 diff --git a/Zend/tests/match/037.phpt b/Zend/tests/match/037.phpt new file mode 100644 index 0000000000000..40dbe4768a7a8 --- /dev/null +++ b/Zend/tests/match/037.phpt @@ -0,0 +1,68 @@ +--TEST-- +Test match jumptable with only one arm +--FILE-- + 'foo', + }); +} catch (Error $e) { + var_dump((string) $e); +} + +try { + var_dump(match(6) { + 1, 2, 3, 4, 5 => 'foo', + }); +} catch (Error $e) { + var_dump((string) $e); +} + +try { + var_dump(match('3') { + 1, 2, 3, 4, 5 => 'foo', + }); +} catch (Error $e) { + var_dump((string) $e); +} + +var_dump(match(3) { + 1, 2, 3, 4, 5 => 'foo', +}); + +var_dump(match(true) { + 1, 2, 3, 4, 5 => 'foo', + default => 'bar', +}); + +var_dump(match(6) { + 1, 2, 3, 4, 5 => 'foo', + default => 'bar', +}); + +var_dump(match('3') { + 1, 2, 3, 4, 5 => 'foo', + default => 'bar', +}); + +var_dump(match(3) { + 1, 2, 3, 4, 5 => 'foo', + default => 'bar', +}); + +--EXPECTF-- +string(%d) "UnhandledMatchError in %s037.php:5 +Stack trace: +#0 {main}" +string(%d) "UnhandledMatchError in %s037.php:13 +Stack trace: +#0 {main}" +string(%d) "UnhandledMatchError in %s037.php:21 +Stack trace: +#0 {main}" +string(3) "foo" +string(3) "bar" +string(3) "bar" +string(3) "bar" +string(3) "foo" diff --git a/Zend/tests/match/038.phpt b/Zend/tests/match/038.phpt new file mode 100644 index 0000000000000..cc158038a9b19 --- /dev/null +++ b/Zend/tests/match/038.phpt @@ -0,0 +1,15 @@ +--TEST-- +Test multiple default arms in match in different arms +--FILE-- + 'foo', + 1 => 'bar', + 2 => 'baz', + default => 'qux', +}; + +?> +--EXPECTF-- +Fatal error: Match expressions may only contain one default arm in %s on line 7 diff --git a/Zend/tests/match/039.phpt b/Zend/tests/match/039.phpt new file mode 100644 index 0000000000000..d37aed5986fd9 --- /dev/null +++ b/Zend/tests/match/039.phpt @@ -0,0 +1,61 @@ +--TEST-- +Test match with duplicate conditions +--FILE-- + 1, + 2 => 2, + 3 => 3, + 4 => 4, + 5 => 5, + 1 => 6, +}; +echo "\n"; + +echo match ($value) { + 2, 1 => '2, 1', + 1 => 1, + 3 => 3, + 4 => 4, + 5 => 5, +}; +echo "\n"; + +echo match ($value) { + 1, 1 => '1, 1', + 2, 2 => '2, 2', + 3, 3 => '3, 3', + 4, 4 => '4, 4', + 5, 5 => '5, 5', +}; +echo "\n"; + +echo match ($value) { + 1 => 1, + 1 => 2, +}; +echo "\n"; + +echo match ($value) { + 2, 1 => '2, 1', + 1 => 1, +}; +echo "\n"; + +echo match ($value) { + 1, 1 => '1, 1', + 1 => 1, +}; +echo "\n"; + +?> +--EXPECT-- +1 +2, 1 +1, 1 +1 +2, 1 +1, 1 diff --git a/Zend/tests/match/040.phpt b/Zend/tests/match/040.phpt new file mode 100644 index 0000000000000..223c3727ecb89 --- /dev/null +++ b/Zend/tests/match/040.phpt @@ -0,0 +1,44 @@ +--TEST-- +Test match with mixed int/string jumptable +--FILE-- + '1 int', + '1' => '1 string', + 2 => '2 int', + '2' => '2 string', + 3 => '3 int', + '3' => '3 string', + 4 => '4 int', + '4' => '4 string', + 5 => '5 int', + '5' => '5 string', + }; + echo "\n"; +} + +test(1); +test('1'); +test(2); +test('2'); +test(3); +test('3'); +test(4); +test('4'); +test(5); +test('5'); + +?> +--EXPECT-- +1 int +1 string +2 int +2 string +3 int +3 string +4 int +4 string +5 int +5 string diff --git a/Zend/tests/match/041.phpt b/Zend/tests/match/041.phpt new file mode 100644 index 0000000000000..1e22f1d6880b2 --- /dev/null +++ b/Zend/tests/match/041.phpt @@ -0,0 +1,33 @@ +--TEST-- +Match expression with trailing comma in condition list +--FILE-- + "false\n", + true, + 1, + => "true\n", + default, + => "not bool\n", + }; +} + +print_bool(false); +print_bool(0); +print_bool(true); +print_bool(1); +print_bool(2); +print_bool('foo'); + +?> +--EXPECT-- +false +false +true +true +not bool +not bool diff --git a/Zend/tests/match/042.phpt b/Zend/tests/match/042.phpt new file mode 100644 index 0000000000000..0220cf40440f9 --- /dev/null +++ b/Zend/tests/match/042.phpt @@ -0,0 +1,14 @@ +--TEST-- +Match expression with undefined variable as expression +--FILE-- + null, + default => 'default', +}); + +?> +--EXPECTF-- +Warning: Undefined variable $undefinedVariable in %s.php on line 3 +NULL diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c index 5ffaabfc689f6..b1e564b5e90dd 100644 --- a/Zend/zend_ast.c +++ b/Zend/zend_ast.c @@ -1590,6 +1590,7 @@ static ZEND_COLD void zend_ast_export_ex(smart_str *str, zend_ast *ast, int prio break; case ZEND_AST_SWITCH_LIST: case ZEND_AST_CATCH_LIST: + case ZEND_AST_MATCH_ARM_LIST: zend_ast_export_list(str, (zend_ast_list*)ast, 0, 0, indent); break; case ZEND_AST_CLOSURE_USES: @@ -1967,6 +1968,25 @@ static ZEND_COLD void zend_ast_export_ex(smart_str *str, zend_ast *ast, int prio } zend_ast_export_stmt(str, ast->child[1], indent + 1); break; + case ZEND_AST_MATCH: + smart_str_appends(str, "match ("); + zend_ast_export_ex(str, ast->child[0], 0, indent); + smart_str_appends(str, ") {\n"); + zend_ast_export_ex(str, ast->child[1], 0, indent + 1); + zend_ast_export_indent(str, indent); + smart_str_appendc(str, '}'); + break; + case ZEND_AST_MATCH_ARM: + zend_ast_export_indent(str, indent); + if (ast->child[0]) { + zend_ast_export_list(str, (zend_ast_list*)ast->child[0], 1, 0, indent); + smart_str_appends(str, " => "); + } else { + smart_str_appends(str, "default => "); + } + zend_ast_export_ex(str, ast->child[1], 0, 0); + smart_str_appends(str, ",\n"); + break; case ZEND_AST_DECLARE: smart_str_appends(str, "declare("); ZEND_ASSERT(ast->child[0]->kind == ZEND_AST_CONST_DECL); diff --git a/Zend/zend_ast.h b/Zend/zend_ast.h index 825c392a18da4..13f43bdc413be 100644 --- a/Zend/zend_ast.h +++ b/Zend/zend_ast.h @@ -63,6 +63,7 @@ enum _zend_ast_kind { ZEND_AST_USE, ZEND_AST_TYPE_UNION, ZEND_AST_ATTRIBUTE_LIST, + ZEND_AST_MATCH_ARM_LIST, /* 0 child nodes */ ZEND_AST_MAGIC_CONST = 0 << ZEND_AST_NUM_CHILDREN_SHIFT, @@ -141,6 +142,8 @@ enum _zend_ast_kind { ZEND_AST_GROUP_USE, ZEND_AST_CLASS_CONST_GROUP, ZEND_AST_ATTRIBUTE, + ZEND_AST_MATCH, + ZEND_AST_MATCH_ARM, /* 3 child nodes */ ZEND_AST_METHOD_CALL = 3 << ZEND_AST_NUM_CHILDREN_SHIFT, diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 205704a6348c0..5ee40879d3b47 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -2113,6 +2113,7 @@ ZEND_API int zend_is_smart_branch(const zend_op *opline) /* {{{ */ case ZEND_IS_SMALLER: case ZEND_IS_SMALLER_OR_EQUAL: case ZEND_CASE: + case ZEND_CASE_STRICT: case ZEND_ISSET_ISEMPTY_CV: case ZEND_ISSET_ISEMPTY_VAR: case ZEND_ISSET_ISEMPTY_DIM_OBJ: @@ -5017,7 +5018,7 @@ static zend_uchar determine_switch_jumptable_type(zend_ast_list *cases) { return common_type; } -static zend_bool should_use_jumptable(zend_ast_list *cases, zend_uchar jumptable_type) { +static zend_bool should_use_jumptable(uint32_t num_children, zend_uchar jumptable_type) { if (CG(compiler_options) & ZEND_COMPILE_NO_JUMPTABLES) { return 0; } @@ -5025,10 +5026,10 @@ static zend_bool should_use_jumptable(zend_ast_list *cases, zend_uchar jumptable /* Thresholds are chosen based on when the average switch time for equidistributed * input becomes smaller when using the jumptable optimization. */ if (jumptable_type == IS_LONG) { - return cases->children >= 5; + return num_children >= 5; } else { ZEND_ASSERT(jumptable_type == IS_STRING); - return cases->children >= 2; + return num_children >= 2; } } @@ -5054,7 +5055,7 @@ void zend_compile_switch(zend_ast *ast) /* {{{ */ case_node.u.op.var = get_temporary_variable(); jumptable_type = determine_switch_jumptable_type(cases); - if (jumptable_type != IS_UNDEF && should_use_jumptable(cases, jumptable_type)) { + if (jumptable_type != IS_UNDEF && should_use_jumptable(cases->children, jumptable_type)) { znode jumptable_op; ALLOC_HASHTABLE(jumptable); @@ -5166,6 +5167,237 @@ void zend_compile_switch(zend_ast *ast) /* {{{ */ } /* }}} */ +static uint32_t count_match_conds(zend_ast_list *arms) +{ + uint32_t num_conds = 0; + + for (uint32_t i = 0; i < arms->children; i++) { + zend_ast *arm_ast = arms->child[i]; + if (arm_ast->child[0] == NULL) { + continue; + } + + zend_ast_list *conds = zend_ast_get_list(arm_ast->child[0]); + num_conds += conds->children; + } + + return num_conds; +} + +static zend_bool can_match_use_jumptable(zend_ast_list *arms) { + for (uint32_t i = 0; i < arms->children; i++) { + zend_ast *arm_ast = arms->child[i]; + if (!arm_ast->child[0]) { + /* Skip default arm */ + continue; + } + + zend_ast_list *conds = zend_ast_get_list(arm_ast->child[0]); + for (uint32_t j = 0; j < conds->children; j++) { + zend_ast **cond_ast = &conds->child[j]; + + zend_eval_const_expr(cond_ast); + if ((*cond_ast)->kind != ZEND_AST_ZVAL) { + return 0; + } + + zval *cond_zv = zend_ast_get_zval(*cond_ast); + if (Z_TYPE_P(cond_zv) != IS_LONG && Z_TYPE_P(cond_zv) != IS_STRING) { + return 0; + } + } + } + + return 1; +} + +void zend_compile_match(znode *result, zend_ast *ast) /* {{{ */ +{ + zend_ast *expr_ast = ast->child[0]; + zend_ast_list *arms = zend_ast_get_list(ast->child[1]); + zend_bool has_default_arm = 0; + uint32_t opnum_match = (uint32_t)-1; + + znode expr_node; + zend_compile_expr(&expr_node, expr_ast); + + znode case_node; + case_node.op_type = IS_TMP_VAR; + case_node.u.op.var = get_temporary_variable(); + + uint32_t num_conds = count_match_conds(arms); + zend_uchar can_use_jumptable = can_match_use_jumptable(arms); + zend_bool uses_jumptable = can_use_jumptable && num_conds >= 2; + HashTable *jumptable = NULL; + uint32_t *jmpnz_opnums = NULL; + + for (uint32_t i = 0; i < arms->children; ++i) { + zend_ast *arm_ast = arms->child[i]; + + if (!arm_ast->child[0]) { + if (has_default_arm) { + CG(zend_lineno) = arm_ast->lineno; + zend_error_noreturn(E_COMPILE_ERROR, + "Match expressions may only contain one default arm"); + } + has_default_arm = 1; + } + } + + if (uses_jumptable) { + znode jumptable_op; + + ALLOC_HASHTABLE(jumptable); + zend_hash_init(jumptable, num_conds, NULL, NULL, 0); + jumptable_op.op_type = IS_CONST; + ZVAL_ARR(&jumptable_op.u.constant, jumptable); + + zend_op *opline = zend_emit_op(NULL, ZEND_MATCH, &expr_node, &jumptable_op); + if (opline->op1_type == IS_CONST) { + Z_TRY_ADDREF_P(CT_CONSTANT(opline->op1)); + } + opnum_match = opline - CG(active_op_array)->opcodes; + } else { + jmpnz_opnums = safe_emalloc(sizeof(uint32_t), num_conds, 0); + uint32_t cond_count = 0; + for (uint32_t i = 0; i < arms->children; ++i) { + zend_ast *arm_ast = arms->child[i]; + + if (!arm_ast->child[0]) { + continue; + } + + zend_ast_list *conds = zend_ast_get_list(arm_ast->child[0]); + for (uint32_t j = 0; j < conds->children; j++) { + zend_ast *cond_ast = conds->child[j]; + + znode cond_node; + zend_compile_expr(&cond_node, cond_ast); + + uint32_t opcode = (expr_node.op_type & (IS_VAR|IS_TMP_VAR)) ? ZEND_CASE_STRICT : ZEND_IS_IDENTICAL; + zend_op *opline = zend_emit_op(NULL, opcode, &expr_node, &cond_node); + SET_NODE(opline->result, &case_node); + if (opline->op1_type == IS_CONST) { + Z_TRY_ADDREF_P(CT_CONSTANT(opline->op1)); + } + + jmpnz_opnums[cond_count] = zend_emit_cond_jump(ZEND_JMPNZ, &case_node, 0); + + cond_count++; + } + } + } + + uint32_t opnum_default_jmp = 0; + if (!uses_jumptable) { + opnum_default_jmp = zend_emit_jump(0); + } + + zend_bool is_first_case = 1; + uint32_t cond_count = 0; + uint32_t *jmp_end_opnums = safe_emalloc(sizeof(uint32_t), arms->children, 0); + + for (uint32_t i = 0; i < arms->children; ++i) { + zend_ast *arm_ast = arms->child[i]; + zend_ast *body_ast = arm_ast->child[1]; + + if (arm_ast->child[0] != NULL) { + zend_ast_list *conds = zend_ast_get_list(arm_ast->child[0]); + + for (uint32_t j = 0; j < conds->children; j++) { + zend_ast *cond_ast = conds->child[j]; + + if (jmpnz_opnums != NULL) { + zend_update_jump_target_to_next(jmpnz_opnums[cond_count]); + } + + if (jumptable) { + zval *cond_zv = zend_ast_get_zval(cond_ast); + zval jmp_target; + ZVAL_LONG(&jmp_target, get_next_op_number()); + + if (Z_TYPE_P(cond_zv) == IS_LONG) { + zend_hash_index_add(jumptable, Z_LVAL_P(cond_zv), &jmp_target); + } else { + ZEND_ASSERT(Z_TYPE_P(cond_zv) == IS_STRING); + zend_hash_add(jumptable, Z_STR_P(cond_zv), &jmp_target); + } + } + + cond_count++; + } + } else { + if (!uses_jumptable) { + zend_update_jump_target_to_next(opnum_default_jmp); + } + + if (jumptable) { + ZEND_ASSERT(opnum_match != (uint32_t)-1); + zend_op *opline = &CG(active_op_array)->opcodes[opnum_match]; + opline->extended_value = get_next_op_number(); + } + } + + znode body_node; + zend_compile_expr(&body_node, body_ast); + + if (is_first_case) { + zend_emit_op_tmp(result, ZEND_QM_ASSIGN, &body_node, NULL); + is_first_case = 0; + } else { + zend_op *opline_qm_assign = zend_emit_op(NULL, ZEND_QM_ASSIGN, &body_node, NULL); + SET_NODE(opline_qm_assign->result, result); + } + + jmp_end_opnums[i] = zend_emit_jump(0); + } + + // Initialize result in case there is no arm + if (arms->children == 0) { + result->op_type = IS_CONST; + ZVAL_NULL(&result->u.constant); + } + + if (!has_default_arm) { + if (!uses_jumptable) { + zend_update_jump_target_to_next(opnum_default_jmp); + } + + if (jumptable) { + zend_op *opline = &CG(active_op_array)->opcodes[opnum_match]; + opline->extended_value = get_next_op_number(); + } + + zval error_name; + ZVAL_STRING(&error_name, "UnhandledMatchError"); + zend_ast *error_name_ast = zend_ast_create_zval(&error_name); + + zend_ast *error_args_ast = zend_ast_create_list(0, ZEND_AST_ARG_LIST); + zend_ast *new_error_ast = zend_ast_create(ZEND_AST_NEW, error_name_ast, error_args_ast); + zend_ast *throw_ast = zend_ast_create(ZEND_AST_THROW, new_error_ast); + zend_compile_throw(NULL, throw_ast); + + zval_ptr_dtor(&error_name); + } + + for (uint32_t i = 0; i < arms->children; ++i) { + zend_update_jump_target_to_next(jmp_end_opnums[i]); + } + + if (expr_node.op_type & (IS_VAR|IS_TMP_VAR)) { + zend_op *opline = zend_emit_op(NULL, ZEND_FREE, &expr_node, NULL); + opline->extended_value = ZEND_FREE_SWITCH; + } else if (expr_node.op_type == IS_CONST) { + zval_ptr_dtor_nogc(&expr_node.u.constant); + } + + if (jmpnz_opnums != NULL) { + efree(jmpnz_opnums); + } + efree(jmp_end_opnums); +} +/* }}} */ + void zend_compile_try(zend_ast *ast) /* {{{ */ { zend_ast *try_ast = ast->child[0]; @@ -9176,6 +9408,9 @@ void zend_compile_expr(znode *result, zend_ast *ast) /* {{{ */ case ZEND_AST_THROW: zend_compile_throw(result, ast); return; + case ZEND_AST_MATCH: + zend_compile_match(result, ast); + return; default: ZEND_ASSERT(0 /* not supported */); } diff --git a/Zend/zend_exceptions.c b/Zend/zend_exceptions.c index 0103422f942da..989d007102084 100644 --- a/Zend/zend_exceptions.c +++ b/Zend/zend_exceptions.c @@ -40,6 +40,7 @@ ZEND_API zend_class_entry *zend_ce_argument_count_error; ZEND_API zend_class_entry *zend_ce_value_error; ZEND_API zend_class_entry *zend_ce_arithmetic_error; ZEND_API zend_class_entry *zend_ce_division_by_zero_error; +ZEND_API zend_class_entry *zend_ce_unhandled_match_error; /* Internal pseudo-exception that is not exposed to userland. */ static zend_class_entry zend_ce_unwind_exit; @@ -800,6 +801,10 @@ void zend_register_default_exception(void) /* {{{ */ zend_ce_division_by_zero_error->create_object = zend_default_exception_new; INIT_CLASS_ENTRY(zend_ce_unwind_exit, "UnwindExit", NULL); + + INIT_CLASS_ENTRY(ce, "UnhandledMatchError", NULL); + zend_ce_unhandled_match_error = zend_register_internal_class_ex(&ce, zend_ce_error); + zend_ce_unhandled_match_error->create_object = zend_default_exception_new; } /* }}} */ diff --git a/Zend/zend_exceptions.h b/Zend/zend_exceptions.h index fdae31a0137c9..95ed0f3e243da 100644 --- a/Zend/zend_exceptions.h +++ b/Zend/zend_exceptions.h @@ -35,6 +35,7 @@ extern ZEND_API zend_class_entry *zend_ce_argument_count_error; extern ZEND_API zend_class_entry *zend_ce_value_error; extern ZEND_API zend_class_entry *zend_ce_arithmetic_error; extern ZEND_API zend_class_entry *zend_ce_division_by_zero_error; +extern ZEND_API zend_class_entry *zend_ce_unhandled_match_error; ZEND_API void zend_exception_set_previous(zend_object *exception, zend_object *add_previous); ZEND_API void zend_exception_save(void); diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y index 7827a178f6f5b..b9674010cb7be 100644 --- a/Zend/zend_language_parser.y +++ b/Zend/zend_language_parser.y @@ -130,6 +130,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %token T_ENDSWITCH "endswitch (T_ENDSWITCH)" %token T_CASE "case (T_CASE)" %token T_DEFAULT "default (T_DEFAULT)" +%token T_MATCH "match (T_MATCH)" %token T_BREAK "break (T_BREAK)" %token T_CONTINUE "continue (T_CONTINUE)" %token T_GOTO "goto (T_GOTO)" @@ -261,6 +262,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %type inline_function union_type %type attributed_statement attributed_class_statement attributed_parameter %type attribute_decl attribute attributes +%type match match_arm_list non_empty_match_arm_list match_arm match_arm_cond_list match_arm_body %type returns_ref function fn is_reference is_variadic variable_modifiers %type method_modifiers non_empty_member_modifiers member_modifier optional_visibility_modifier @@ -284,7 +286,7 @@ reserved_non_modifiers: | T_THROW | T_USE | T_INSTEADOF | T_GLOBAL | T_VAR | T_UNSET | T_ISSET | T_EMPTY | T_CONTINUE | T_GOTO | T_FUNCTION | T_CONST | T_RETURN | T_PRINT | T_YIELD | T_LIST | T_SWITCH | T_ENDSWITCH | T_CASE | T_DEFAULT | T_BREAK | T_ARRAY | T_CALLABLE | T_EXTENDS | T_IMPLEMENTS | T_NAMESPACE | T_TRAIT | T_INTERFACE | T_CLASS - | T_CLASS_C | T_TRAIT_C | T_FUNC_C | T_METHOD_C | T_LINE | T_FILE | T_DIR | T_NS_C | T_FN + | T_CLASS_C | T_TRAIT_C | T_FUNC_C | T_METHOD_C | T_LINE | T_FILE | T_DIR | T_NS_C | T_FN | T_MATCH ; semi_reserved: @@ -624,6 +626,38 @@ case_separator: ; +match: + T_MATCH '(' expr ')' '{' match_arm_list '}' + { $$ = zend_ast_create(ZEND_AST_MATCH, $3, $6); }; +; + +match_arm_list: + %empty { $$ = zend_ast_create_list(0, ZEND_AST_MATCH_ARM_LIST); } + | non_empty_match_arm_list possible_comma { $$ = $1; } +; + +non_empty_match_arm_list: + match_arm { $$ = zend_ast_create_list(1, ZEND_AST_MATCH_ARM_LIST, $1); } + | non_empty_match_arm_list ',' match_arm { $$ = zend_ast_list_add($1, $3); } +; + +match_arm: + match_arm_cond_list possible_comma T_DOUBLE_ARROW match_arm_body + { $$ = zend_ast_create(ZEND_AST_MATCH_ARM, $1, $4); } + | T_DEFAULT possible_comma T_DOUBLE_ARROW match_arm_body + { $$ = zend_ast_create(ZEND_AST_MATCH_ARM, NULL, $4); } +; + +match_arm_cond_list: + expr { $$ = zend_ast_create_list(1, ZEND_AST_EXPR_LIST, $1); } + | match_arm_cond_list ',' expr { $$ = zend_ast_list_add($1, $3); } +; + +match_arm_body: + expr { $$ = $1; } +; + + while_statement: statement { $$ = $1; } | ':' inner_statement_list T_ENDWHILE ';' { $$ = $2; } @@ -1079,6 +1113,7 @@ expr: | T_STATIC inline_function { $$ = $2; ((zend_ast_decl *) $$)->flags |= ZEND_ACC_STATIC; } | attributes T_STATIC inline_function { $$ = zend_ast_with_attributes($3, $1); ((zend_ast_decl *) $$)->flags |= ZEND_ACC_STATIC; } + | match { $$ = $1; } ; diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l index 4580b858e015b..b6cd505a633aa 100644 --- a/Zend/zend_language_scanner.l +++ b/Zend/zend_language_scanner.l @@ -1512,6 +1512,10 @@ NEWLINE ("\r"|"\n"|"\r\n") RETURN_TOKEN_WITH_IDENT(T_SWITCH); } +"match" { + RETURN_TOKEN_WITH_IDENT(T_MATCH); +} + "endswitch" { RETURN_TOKEN_WITH_IDENT(T_ENDSWITCH); } diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c index 983b362046d0f..06f2b9b19d147 100644 --- a/Zend/zend_opcode.c +++ b/Zend/zend_opcode.c @@ -763,7 +763,9 @@ static zend_bool keeps_op1_alive(zend_op *opline) { /* These opcodes don't consume their OP1 operand, * it is later freed by something else. */ if (opline->opcode == ZEND_CASE + || opline->opcode == ZEND_CASE_STRICT || opline->opcode == ZEND_SWITCH_LONG + || opline->opcode == ZEND_MATCH || opline->opcode == ZEND_FETCH_LIST_R || opline->opcode == ZEND_COPY_TMP) { return 1; @@ -1039,6 +1041,7 @@ ZEND_API int pass_two(zend_op_array *op_array) break; case ZEND_SWITCH_LONG: case ZEND_SWITCH_STRING: + case ZEND_MATCH: { /* absolute indexes to relative offsets */ HashTable *jumptable = Z_ARRVAL_P(CT_CONSTANT(opline->op2)); @@ -1108,6 +1111,7 @@ ZEND_API binary_op_type get_binary_op(int opcode) case ZEND_CONCAT: return (binary_op_type) concat_function; case ZEND_IS_IDENTICAL: + case ZEND_CASE_STRICT: return (binary_op_type) is_identical_function; case ZEND_IS_NOT_IDENTICAL: return (binary_op_type) is_not_identical_function; diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 1d02031b97920..5f11090eae056 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -457,6 +457,20 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(16, ZEND_IS_IDENTICAL, CONST|TMP|VAR|CV, CONST|T ZEND_VM_SMART_BRANCH(result, 1); } +ZEND_VM_HANDLER(196, ZEND_CASE_STRICT, TMP|VAR, CONST|TMP|VAR|CV) +{ + USE_OPLINE + zval *op1, *op2; + zend_bool result; + + SAVE_OPLINE(); + op1 = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R); + op2 = GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R); + result = fast_is_identical_function(op1, op2); + FREE_OP2(); + ZEND_VM_SMART_BRANCH(result, 1); +} + ZEND_VM_COLD_CONSTCONST_HANDLER(17, ZEND_IS_NOT_IDENTICAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV, SPEC(COMMUTATIVE)) { USE_OPLINE @@ -8394,6 +8408,44 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(188, ZEND_SWITCH_STRING, CONST|TMPVARCV, CONST, } } +ZEND_VM_COLD_CONSTCONST_HANDLER(195, ZEND_MATCH, CONST|TMPVARCV, CONST, JMP_ADDR) +{ + USE_OPLINE + zval *op, *jump_zv; + HashTable *jumptable; + + op = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R); + jumptable = Z_ARRVAL_P(GET_OP2_ZVAL_PTR(BP_VAR_R)); + +ZEND_VM_C_LABEL(match_try_again): + if (Z_TYPE_P(op) == IS_LONG) { + jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op)); + } else if (Z_TYPE_P(op) == IS_STRING) { + jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), OP1_TYPE == IS_CONST); + } else if (Z_TYPE_P(op) == IS_REFERENCE) { + op = Z_REFVAL_P(op); + ZEND_VM_C_GOTO(match_try_again); + } else { + if (UNEXPECTED((OP1_TYPE & IS_CV) && Z_TYPE_P(op) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + ZEND_VM_C_GOTO(default_branch); + } + + if (jump_zv != NULL) { + ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv)); + ZEND_VM_CONTINUE(); + } else { +ZEND_VM_C_LABEL(default_branch): + /* default */ + ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value); + ZEND_VM_CONTINUE(); + } +} + ZEND_VM_COLD_CONSTCONST_HANDLER(189, ZEND_IN_ARRAY, CONST|TMP|VAR|CV, CONST, NUM) { USE_OPLINE diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index a4c444599c220..9fbf240c54290 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -6496,6 +6496,44 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_STRING_SPE } } +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op, *jump_zv; + HashTable *jumptable; + + op = RT_CONSTANT(opline, opline->op1); + jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2)); + +match_try_again: + if (Z_TYPE_P(op) == IS_LONG) { + jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op)); + } else if (Z_TYPE_P(op) == IS_STRING) { + jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), IS_CONST == IS_CONST); + } else if (Z_TYPE_P(op) == IS_REFERENCE) { + op = Z_REFVAL_P(op); + goto match_try_again; + } else { + if (UNEXPECTED((IS_CONST & IS_CV) && Z_TYPE_P(op) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + goto default_branch; + } + + if (jump_zv != NULL) { + ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv)); + ZEND_VM_CONTINUE(); + } else { +default_branch: + /* default */ + ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value); + ZEND_VM_CONTINUE(); + } +} + static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -11350,6 +11388,44 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_STRING_SPEC_TMPVARCV_CO } } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op, *jump_zv; + HashTable *jumptable; + + op = EX_VAR(opline->op1.var); + jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2)); + +match_try_again: + if (Z_TYPE_P(op) == IS_LONG) { + jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op)); + } else if (Z_TYPE_P(op) == IS_STRING) { + jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST); + } else if (Z_TYPE_P(op) == IS_REFERENCE) { + op = Z_REFVAL_P(op); + goto match_try_again; + } else { + if (UNEXPECTED(((IS_TMP_VAR|IS_VAR|IS_CV) & IS_CV) && Z_TYPE_P(op) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + goto default_branch; + } + + if (jump_zv != NULL) { + ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv)); + ZEND_VM_CONTINUE(); + } else { +default_branch: + /* default */ + ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value); + ZEND_VM_CONTINUE(); + } +} + static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -17922,6 +17998,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HA ZEND_VM_SMART_BRANCH(result, 1); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + zend_bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + result = fast_is_identical_function(op1, op2); + + ZEND_VM_SMART_BRANCH(result, 1); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -18723,6 +18813,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HAND ZEND_VM_SMART_BRANCH(result, 1); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + zend_bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -18738,6 +18842,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_ ZEND_VM_SMART_BRANCH(result, 1); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + zend_bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { #if 0 @@ -19073,6 +19191,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDL ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + zend_bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + + ZEND_VM_SMART_BRANCH(result, 1); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { #if 0 @@ -20943,6 +21075,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HA ZEND_VM_SMART_BRANCH(result, 1); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + zend_bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + result = fast_is_identical_function(op1, op2); + + ZEND_VM_SMART_BRANCH(result, 1); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -25349,6 +25495,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HAND ZEND_VM_SMART_BRANCH(result, 1); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + zend_bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -25419,6 +25579,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HAND ZEND_VM_SMART_BRANCH(result, 1); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + zend_bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -26657,6 +26831,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDL ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + zend_bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + + ZEND_VM_SMART_BRANCH(result, 1); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -50838,6 +51026,36 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_LABEL, + (void*)&&ZEND_MATCH_SPEC_CONST_CONST_LABEL, + (void*)&&ZEND_MATCH_SPEC_TMPVARCV_CONST_LABEL, + (void*)&&ZEND_MATCH_SPEC_TMPVARCV_CONST_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_MATCH_SPEC_TMPVARCV_CONST_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_CASE_STRICT_SPEC_TMP_CONST_LABEL, + (void*)&&ZEND_CASE_STRICT_SPEC_TMP_TMP_LABEL, + (void*)&&ZEND_CASE_STRICT_SPEC_TMP_VAR_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_CASE_STRICT_SPEC_TMP_CV_LABEL, + (void*)&&ZEND_CASE_STRICT_SPEC_VAR_CONST_LABEL, + (void*)&&ZEND_CASE_STRICT_SPEC_VAR_TMP_LABEL, + (void*)&&ZEND_CASE_STRICT_SPEC_VAR_VAR_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_CASE_STRICT_SPEC_VAR_CV_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL, (void*)&&ZEND_JMP_FORWARD_SPEC_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -52490,6 +52708,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_SWITCH_STRING_SPEC_CONST_CONST) ZEND_SWITCH_STRING_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_MATCH_SPEC_CONST_CONST): + VM_TRACE(ZEND_MATCH_SPEC_CONST_CONST) + ZEND_MATCH_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_IN_ARRAY_SPEC_CONST_CONST): VM_TRACE(ZEND_IN_ARRAY_SPEC_CONST_CONST) ZEND_IN_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -52938,6 +53160,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_MATCH_SPEC_TMPVARCV_CONST): + VM_TRACE(ZEND_MATCH_SPEC_TMPVARCV_CONST) + ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST): VM_TRACE(ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -53755,6 +53981,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_IS_IDENTICAL_SPEC_TMP_CONST) ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_CONST): + VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_CONST) + ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST): VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST) ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -53823,10 +54053,18 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_IS_IDENTICAL_SPEC_TMP_TMP) ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_TMP): + VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_TMP) + ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP): VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP) ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_VAR): + VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_VAR) + ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED): VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -53851,6 +54089,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_GET_TYPE_SPEC_TMP_UNUSED) ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_CV): + VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_CV) + ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV): VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -54068,6 +54310,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_CONST) ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_CONST): + VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_CONST) + ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST): VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST) ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -54332,6 +54578,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_TMP) ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_TMP): + VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_TMP) + ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP): VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP) ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -54348,6 +54598,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_VAR) ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_VAR): + VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_VAR) + ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR): VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR) ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -54432,6 +54686,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_GET_TYPE_SPEC_VAR_UNUSED) ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_CV): + VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_CV) + ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV): VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV) ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -58382,6 +58640,36 @@ void zend_vm_init(void) ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER, + ZEND_MATCH_SPEC_CONST_CONST_HANDLER, + ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER, + ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER, + ZEND_NULL_HANDLER, + ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER, + ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER, + ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER, + ZEND_NULL_HANDLER, + ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER, + ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER, + ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER, + ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER, + ZEND_NULL_HANDLER, + ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, ZEND_RECV_NOTYPE_SPEC_HANDLER, ZEND_JMP_FORWARD_SPEC_HANDLER, ZEND_NULL_HANDLER, @@ -59483,7 +59771,9 @@ void zend_vm_init(void) 2284, 2285 | SPEC_RULE_OP1, 2290 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3218 + 2315 | SPEC_RULE_OP1, + 2320 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 3248 }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -59648,7 +59938,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 = 2317 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2347 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -59656,7 +59946,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 = 2342 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2372 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -59664,7 +59954,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 = 2367 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2397 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -59675,17 +59965,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 = 2392 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2422 | 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 = 2417 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2447 | 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 = 2442 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2472 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -59696,17 +59986,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 = 2467 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2497 | 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 = 2492 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2522 | 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 = 2517 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2547 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -59717,14 +60007,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 = 2542 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2572 | 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 = 2617 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2647 | 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 = 2842 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2872 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -59735,14 +60025,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 = 2692 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2722 | 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 = 2767 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2797 | 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 = 2847 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2877 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -59753,12 +60043,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 = 2542 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2572 | 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 = 2617 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2647 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -59769,12 +60059,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 = 2692 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2722 | 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 = 2767 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2797 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -59782,12 +60072,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 = 2852 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 2882 | 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 = 2927 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 2957 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -59795,74 +60085,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 = 3002 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3032 | 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 = 3077 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3107 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3164 | SPEC_RULE_OP1; + spec = 3194 | SPEC_RULE_OP1; } else if (op1_info == MAY_BE_DOUBLE) { - spec = 3169 | SPEC_RULE_OP1; + spec = 3199 | 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 = 3174 | SPEC_RULE_OP1; + spec = 3204 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3152 | SPEC_RULE_RETVAL; + spec = 3182 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3154 | SPEC_RULE_RETVAL; + spec = 3184 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3156 | SPEC_RULE_RETVAL; + spec = 3186 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3158 | SPEC_RULE_RETVAL; + spec = 3188 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3160; + spec = 3190; } else if (op1_info == MAY_BE_LONG) { - spec = 3161; + spec = 3191; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3162; + spec = 3192; } else if (op1_info == MAY_BE_LONG) { - spec = 3163; + spec = 3193; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2316; + spec = 2346; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2315; + spec = 2345; } break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3214; + spec = 3244; } break; case ZEND_SEND_VAR_EX: if (op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3209 | SPEC_RULE_OP1; + spec = 3239 | SPEC_RULE_OP1; } break; case ZEND_FE_FETCH_R: if (op->op2_type == IS_CV && (op1_info & (MAY_BE_UNDEF|MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 3216 | SPEC_RULE_RETVAL; + spec = 3246 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -59870,17 +60160,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 = 3179 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3209 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_SEND_VAL_EX: if (op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3215; + spec = 3245; } break; case ZEND_SEND_VAR: if ((op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3204 | SPEC_RULE_OP1; + spec = 3234 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index e5d50a408304e..7a1fa9c98dd14 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -1287,149 +1287,149 @@ _(2311, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ _(2312, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \ _(2314, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \ - _(2315, ZEND_RECV_NOTYPE_SPEC) \ - _(2316, ZEND_JMP_FORWARD_SPEC) \ - _(2322, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2323, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2324, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2326, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2327, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2328, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2329, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2331, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2337, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2338, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2339, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2341, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2347, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2348, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2349, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2351, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2352, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2353, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2354, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2356, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2362, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2363, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2364, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2366, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2372, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2373, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2374, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2376, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2377, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2378, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2379, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2381, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2387, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2388, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2389, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2391, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2393, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2394, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2396, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2397, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2398, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2399, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2401, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2402, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2403, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2404, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2406, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2412, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2413, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2414, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2416, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2418, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2419, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2421, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2422, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2423, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2424, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2426, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2427, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2428, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2429, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2431, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2437, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2438, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2439, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2441, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2443, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2444, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2446, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2447, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2448, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2449, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2451, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2452, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2453, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2454, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2456, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2462, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2463, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2464, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2466, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2472, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2473, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2474, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2476, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2477, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2478, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2479, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2481, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2487, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2488, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2489, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2491, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2497, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2498, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2499, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2501, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2502, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2503, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2504, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2506, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2512, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2513, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2514, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2516, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2522, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2523, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2524, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2526, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2527, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2528, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2529, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2531, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2537, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2538, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2539, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2541, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2557, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2558, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2559, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2560, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2561, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2562, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2563, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2564, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2565, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2569, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2570, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2571, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2572, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2573, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2574, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2575, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2576, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2577, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2578, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2579, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2580, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2584, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2585, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2586, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2315, ZEND_MATCH_SPEC_CONST_CONST) \ + _(2316, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2317, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2319, ZEND_MATCH_SPEC_TMPVARCV_CONST) \ + _(2325, ZEND_CASE_STRICT_SPEC_TMP_CONST) \ + _(2326, ZEND_CASE_STRICT_SPEC_TMP_TMP) \ + _(2327, ZEND_CASE_STRICT_SPEC_TMP_VAR) \ + _(2329, ZEND_CASE_STRICT_SPEC_TMP_CV) \ + _(2330, ZEND_CASE_STRICT_SPEC_VAR_CONST) \ + _(2331, ZEND_CASE_STRICT_SPEC_VAR_TMP) \ + _(2332, ZEND_CASE_STRICT_SPEC_VAR_VAR) \ + _(2334, ZEND_CASE_STRICT_SPEC_VAR_CV) \ + _(2345, ZEND_RECV_NOTYPE_SPEC) \ + _(2346, ZEND_JMP_FORWARD_SPEC) \ + _(2352, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2353, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2354, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2356, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2357, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2358, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2359, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2361, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2367, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2368, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2369, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2371, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2377, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2378, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2379, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2381, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2382, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2383, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2384, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2386, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2392, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2393, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2394, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2396, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2402, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2403, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2404, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2406, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2407, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2408, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2409, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2411, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2417, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2418, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2419, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2421, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2423, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2424, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2426, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2427, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2428, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2429, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2431, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2432, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2433, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2434, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2436, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2442, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2443, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2444, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2446, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2448, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2449, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2451, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2452, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2453, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2454, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2456, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2457, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2458, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2459, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2461, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2467, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2468, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2469, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2471, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2473, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2474, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2476, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2477, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2478, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2479, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2481, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2482, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2483, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2484, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2486, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2492, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2493, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2494, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2496, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2502, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2503, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2504, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2506, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2507, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2508, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2509, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2511, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2517, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2518, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2519, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2521, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2527, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2528, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2529, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2531, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2532, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2533, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2534, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2536, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2542, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2543, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2544, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2546, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2552, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2553, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2554, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2556, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2557, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2558, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2559, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2561, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2567, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2568, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2569, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2571, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2587, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2588, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2589, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2590, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2591, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2592, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2593, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2594, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2595, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2599, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2600, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2601, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ _(2602, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ _(2603, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ _(2604, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ @@ -1442,30 +1442,30 @@ _(2614, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2615, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(2616, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2632, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2633, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2634, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2635, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2636, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2637, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2638, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2639, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2640, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2644, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2645, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2646, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2647, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2648, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2649, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2650, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2651, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2652, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2653, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2654, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2655, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2659, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2660, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2661, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2632, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2633, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2634, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2635, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2636, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2637, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2638, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2639, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2640, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2644, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2645, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2646, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2662, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2663, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2664, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2665, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2666, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2667, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2668, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2669, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2670, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2674, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2675, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2676, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ _(2677, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2678, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ _(2679, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ @@ -1478,30 +1478,30 @@ _(2689, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2690, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(2691, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2707, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2708, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2709, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2710, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2711, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2712, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2713, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2714, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2715, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2719, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2720, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2721, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2722, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2723, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2724, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2725, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2726, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2727, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2728, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2729, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2730, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2734, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2735, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2736, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2707, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2708, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2709, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2710, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2711, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2712, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2713, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2714, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2715, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2719, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2720, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2721, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2737, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2738, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2739, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2740, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2741, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2742, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2743, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2744, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2745, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2749, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2750, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2751, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ _(2752, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ _(2753, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ _(2754, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ @@ -1514,30 +1514,30 @@ _(2764, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2765, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(2766, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2782, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2783, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2784, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2785, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2786, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2787, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2788, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2789, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2790, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2794, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2795, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2796, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2797, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2798, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2799, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2800, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2801, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2802, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2803, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2804, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2805, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2809, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2810, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2811, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2782, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2783, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2784, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2785, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2786, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2787, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2788, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2789, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2790, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2794, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2795, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2796, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2812, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2813, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2814, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2815, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2816, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2817, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2818, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2819, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2820, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2824, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2825, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2826, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ _(2827, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2828, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ _(2829, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ @@ -1550,43 +1550,43 @@ _(2839, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2840, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(2841, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2842, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(2846, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(2847, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(2851, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(2855, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(2856, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2857, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2858, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(2859, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2860, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2864, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(2865, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2866, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2867, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(2868, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2869, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2870, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2871, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2872, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2873, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2874, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2875, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2879, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2880, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2881, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2882, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(2883, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2884, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2885, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2886, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2887, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2888, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2889, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2890, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2894, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2895, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2896, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2857, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2858, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2859, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2860, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2861, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2862, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2863, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2864, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2865, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2869, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2870, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2871, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2872, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(2876, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(2877, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(2881, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(2885, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(2886, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2887, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2888, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(2889, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2890, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2894, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(2895, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2896, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2897, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(2898, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2899, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2900, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2901, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2902, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2903, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2904, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2905, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2909, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2910, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2911, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ _(2912, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ _(2913, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ _(2914, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ @@ -1599,39 +1599,39 @@ _(2924, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2925, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(2926, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2930, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2931, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2932, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2933, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2934, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2935, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2939, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2940, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2941, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2942, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2943, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2944, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2945, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2946, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2947, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2948, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2949, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2950, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2954, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2955, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2956, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2957, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2958, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2959, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2960, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2961, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2962, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2963, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2964, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2965, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2969, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2970, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2971, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2942, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(2943, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2944, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2945, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2946, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2947, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2948, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2949, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2950, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2954, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2955, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2956, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2960, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2961, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2962, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2963, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2964, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2965, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2969, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2970, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2971, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2972, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2973, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2974, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2975, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2976, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2977, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2978, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2979, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2980, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2984, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2985, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2986, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ _(2987, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2988, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ _(2989, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ @@ -1644,39 +1644,39 @@ _(2999, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3000, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3001, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3005, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3006, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3007, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3008, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3009, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3010, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3014, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3015, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3016, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3017, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3018, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3019, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3020, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3021, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3022, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3023, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3024, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3025, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3029, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3030, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3031, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3032, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3033, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3034, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3035, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3036, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3037, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3038, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3039, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3040, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3044, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3045, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3046, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3017, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3018, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3019, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3020, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3021, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3022, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3023, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3024, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3025, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3029, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3030, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3031, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3035, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3036, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3037, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3038, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3039, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3040, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3044, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3045, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3046, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3047, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3048, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3049, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3050, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3051, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3052, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3053, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3054, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3055, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3059, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3060, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3061, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ _(3062, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ _(3063, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ _(3064, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ @@ -1689,39 +1689,39 @@ _(3074, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(3075, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3076, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3080, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3081, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3082, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3083, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3084, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3085, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3089, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3090, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3091, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3092, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3093, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3094, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3095, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3096, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3097, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3098, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3099, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3100, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3104, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3105, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3106, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3107, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3108, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3109, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3110, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3111, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3112, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3113, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3114, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3115, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3119, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3120, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3121, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3092, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3093, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3094, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3095, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3096, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3097, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3098, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3099, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3100, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3104, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3105, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3106, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3110, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3111, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3112, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3113, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3114, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3115, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3119, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3120, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3121, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3122, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3123, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3124, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3125, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3126, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3127, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3128, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3129, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3130, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3134, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3135, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3136, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ _(3137, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(3138, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ _(3139, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ @@ -1734,51 +1734,63 @@ _(3149, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(3150, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ _(3151, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3152, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3153, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3154, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3155, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3156, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3157, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3158, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3159, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3160, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3161, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3162, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3163, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3164, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ - _(3165, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3166, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3168, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3169, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(3170, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3171, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3173, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3174, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(3175, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3176, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3178, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3180, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3181, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3183, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3184, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3185, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3186, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3188, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3189, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3190, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3191, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3193, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3199, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(3200, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3201, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3203, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3206, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3208, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3211, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \ - _(3213, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \ - _(3214, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3215, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3216, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3217, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3217+1, ZEND_NULL) + _(3167, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3168, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3169, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3170, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3171, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3172, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3173, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3174, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3175, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3179, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3180, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3181, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3182, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3183, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3184, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3185, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3186, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3187, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3188, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3189, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3190, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3191, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3192, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3193, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3194, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3195, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3196, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3198, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3199, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3200, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3201, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3203, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3204, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3205, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3206, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3208, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3210, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3211, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3213, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3214, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3215, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3216, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3218, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3219, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3220, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3221, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3223, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3229, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3230, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3231, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3233, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3236, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3238, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3241, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \ + _(3243, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \ + _(3244, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3245, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3246, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3247, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3247+1, ZEND_NULL) diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index 65733779e490e..08b09d61aae3e 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -22,7 +22,7 @@ #include #include -static const char *zend_vm_opcodes_names[195] = { +static const char *zend_vm_opcodes_names[197] = { "ZEND_NOP", "ZEND_ADD", "ZEND_SUB", @@ -218,9 +218,11 @@ static const char *zend_vm_opcodes_names[195] = { "ZEND_GET_CALLED_CLASS", "ZEND_GET_TYPE", "ZEND_ARRAY_KEY_EXISTS", + "ZEND_MATCH", + "ZEND_CASE_STRICT", }; -static uint32_t zend_vm_opcodes_flags[195] = { +static uint32_t zend_vm_opcodes_flags[197] = { 0x00000000, 0x00000b0b, 0x00000b0b, @@ -416,6 +418,8 @@ static uint32_t zend_vm_opcodes_flags[195] = { 0x00000101, 0x00000103, 0x00000707, + 0x0300030b, + 0x00000301, }; 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 60bcb66643e8b..cad2a79863482 100644 --- a/Zend/zend_vm_opcodes.h +++ b/Zend/zend_vm_opcodes.h @@ -271,7 +271,9 @@ END_EXTERN_C() #define ZEND_GET_CALLED_CLASS 192 #define ZEND_GET_TYPE 193 #define ZEND_ARRAY_KEY_EXISTS 194 +#define ZEND_MATCH 195 +#define ZEND_CASE_STRICT 196 -#define ZEND_VM_LAST_OPCODE 194 +#define ZEND_VM_LAST_OPCODE 196 #endif diff --git a/ext/opcache/Optimizer/block_pass.c b/ext/opcache/Optimizer/block_pass.c index 59429082f7cc3..6cd121a471151 100644 --- a/ext/opcache/Optimizer/block_pass.c +++ b/ext/opcache/Optimizer/block_pass.c @@ -115,6 +115,10 @@ static int get_const_switch_target(zend_cfg *cfg, zend_op_array *op_array, zend_ /* fallback to next block */ return block->successors[block->successors_count - 1]; } + if (opline->opcode == ZEND_MATCH && Z_TYPE_P(val) != IS_LONG && Z_TYPE_P(val) != IS_STRING) { + /* always jump to the default arm */ + return block->successors[block->successors_count - 2]; + } if (Z_TYPE_P(val) == IS_LONG) { zv = zend_hash_index_find(jumptable, Z_LVAL_P(val)); } else { @@ -369,6 +373,7 @@ static void zend_optimize_block(zend_basic_block *block, zend_op_array *op_array case ZEND_SWITCH_LONG: case ZEND_SWITCH_STRING: + case ZEND_MATCH: if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) { /* SWITCH variable will be deleted later by FREE, so we can't optimize it */ Tsource[VAR_NUM(opline->op1.var)] = NULL; @@ -387,6 +392,7 @@ static void zend_optimize_block(zend_basic_block *block, zend_op_array *op_array break; case ZEND_CASE: + case ZEND_CASE_STRICT: case ZEND_COPY_TMP: if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) { /* Variable will be deleted later by FREE, so we can't optimize it */ @@ -1046,6 +1052,7 @@ static void assemble_code_blocks(zend_cfg *cfg, zend_op_array *op_array, zend_op break; case ZEND_SWITCH_LONG: case ZEND_SWITCH_STRING: + case ZEND_MATCH: { HashTable *jumptable = Z_ARRVAL(ZEND_OP2_LITERAL(opline)); zval *zv; diff --git a/ext/opcache/Optimizer/dce.c b/ext/opcache/Optimizer/dce.c index 43f2ef71a242b..2df9d08768e73 100644 --- a/ext/opcache/Optimizer/dce.c +++ b/ext/opcache/Optimizer/dce.c @@ -106,6 +106,7 @@ static inline zend_bool may_have_side_effects( case ZEND_IS_SMALLER: case ZEND_IS_SMALLER_OR_EQUAL: case ZEND_CASE: + case ZEND_CASE_STRICT: case ZEND_CAST: case ZEND_ROPE_INIT: case ZEND_ROPE_ADD: @@ -391,7 +392,8 @@ static zend_bool dce_instr(context *ctx, zend_op *opline, zend_ssa_op *ssa_op) { if ((opline->op1_type & (IS_VAR|IS_TMP_VAR))&& !is_var_dead(ctx, ssa_op->op1_use)) { if (!try_remove_var_def(ctx, ssa_op->op1_use, ssa_op->op1_use_chain, opline)) { if (ssa->var_info[ssa_op->op1_use].type & (MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_OBJECT|MAY_BE_RESOURCE|MAY_BE_REF) - && opline->opcode != ZEND_CASE) { + && opline->opcode != ZEND_CASE + && opline->opcode != ZEND_CASE_STRICT) { free_var = ssa_op->op1_use; free_var_type = opline->op1_type; } diff --git a/ext/opcache/Optimizer/dfa_pass.c b/ext/opcache/Optimizer/dfa_pass.c index a8bff00557d17..da2f445acfd4e 100644 --- a/ext/opcache/Optimizer/dfa_pass.c +++ b/ext/opcache/Optimizer/dfa_pass.c @@ -641,6 +641,7 @@ static void zend_ssa_replace_control_link(zend_op_array *op_array, zend_ssa *ssa break; case ZEND_SWITCH_LONG: case ZEND_SWITCH_STRING: + case ZEND_MATCH: { HashTable *jumptable = Z_ARRVAL(ZEND_OP2_LITERAL(opline)); zval *zv; @@ -895,38 +896,17 @@ static int zend_dfa_optimize_jmps(zend_op_array *op_array, zend_ssa *ssa) break; } case ZEND_SWITCH_LONG: - if (opline->op1_type == IS_CONST) { - zval *zv = CT_CONSTANT_EX(op_array, opline->op1.constant); - if (Z_TYPE_P(zv) != IS_LONG) { - removed_ops++; - MAKE_NOP(opline); - opline->extended_value = 0; - take_successor_ex(ssa, block_num, block, block->successors[0]); - goto optimize_nop; - } else { - HashTable *jmptable = Z_ARRVAL_P(CT_CONSTANT_EX(op_array, opline->op2.constant)); - zval *jmp_zv = zend_hash_index_find(jmptable, Z_LVAL_P(zv)); - uint32_t target; - - if (jmp_zv) { - target = ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, Z_LVAL_P(jmp_zv)); - } else { - target = ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value); - } - opline->opcode = ZEND_JMP; - opline->extended_value = 0; - SET_UNUSED(opline->op1); - ZEND_SET_OP_JMP_ADDR(opline, opline->op1, op_array->opcodes + target); - SET_UNUSED(opline->op2); - take_successor_ex(ssa, block_num, block, ssa->cfg.map[target]); - goto optimize_jmp; - } - } - break; case ZEND_SWITCH_STRING: + case ZEND_MATCH: if (opline->op1_type == IS_CONST) { zval *zv = CT_CONSTANT_EX(op_array, opline->op1.constant); - if (Z_TYPE_P(zv) != IS_STRING) { + zend_uchar type = Z_TYPE_P(zv); + zend_bool correct_type = + (opline->opcode == ZEND_SWITCH_LONG && type == IS_LONG) + || (opline->opcode == ZEND_SWITCH_STRING && type == IS_STRING) + || (opline->opcode == ZEND_MATCH && (type == IS_LONG || type == IS_STRING)); + + if (!correct_type) { removed_ops++; MAKE_NOP(opline); opline->extended_value = 0; @@ -934,9 +914,11 @@ static int zend_dfa_optimize_jmps(zend_op_array *op_array, zend_ssa *ssa) goto optimize_nop; } else { HashTable *jmptable = Z_ARRVAL_P(CT_CONSTANT_EX(op_array, opline->op2.constant)); - zval *jmp_zv = zend_hash_find(jmptable, Z_STR_P(zv)); - uint32_t target; + zval *jmp_zv = type == IS_LONG + ? zend_hash_index_find(jmptable, Z_LVAL_P(zv)) + : zend_hash_find(jmptable, Z_STR_P(zv)); + uint32_t target; if (jmp_zv) { target = ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, Z_LVAL_P(jmp_zv)); } else { diff --git a/ext/opcache/Optimizer/pass1.c b/ext/opcache/Optimizer/pass1.c index 3beb1788a3e76..84e23f118ff32 100644 --- a/ext/opcache/Optimizer/pass1.c +++ b/ext/opcache/Optimizer/pass1.c @@ -82,6 +82,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) case ZEND_BOOL_XOR: case ZEND_SPACESHIP: case ZEND_CASE: + case ZEND_CASE_STRICT: if (opline->op1_type == IS_CONST && opline->op2_type == IS_CONST) { /* binary operation with constant operands */ diff --git a/ext/opcache/Optimizer/sccp.c b/ext/opcache/Optimizer/sccp.c index c51b5c3ee23df..ee8ccc34a7783 100644 --- a/ext/opcache/Optimizer/sccp.c +++ b/ext/opcache/Optimizer/sccp.c @@ -300,10 +300,15 @@ static zend_bool try_replace_op1( switch (opline->opcode) { case ZEND_CASE: opline->opcode = ZEND_IS_EQUAL; - /* break missing intentionally */ + goto replace_op1_simple; + case ZEND_CASE_STRICT: + opline->opcode = ZEND_IS_IDENTICAL; + goto replace_op1_simple; case ZEND_FETCH_LIST_R: case ZEND_SWITCH_STRING: case ZEND_SWITCH_LONG: + case ZEND_MATCH: +replace_op1_simple: if (Z_TYPE(zv) == IS_STRING) { zend_string_hash_val(Z_STR(zv)); } @@ -1460,6 +1465,7 @@ static void sccp_visit_instr(scdf_ctx *scdf, zend_op *opline, zend_ssa_op *ssa_o case ZEND_BW_XOR: case ZEND_BOOL_XOR: case ZEND_CASE: + case ZEND_CASE_STRICT: SKIP_IF_TOP(op1); SKIP_IF_TOP(op2); @@ -1986,11 +1992,23 @@ static void sccp_mark_feasible_successors( s = zend_hash_num_elements(Z_ARR_P(op1)) != 0; break; case ZEND_SWITCH_LONG: - if (Z_TYPE_P(op1) == IS_LONG) { + case ZEND_SWITCH_STRING: + case ZEND_MATCH: + { + zend_bool strict_comparison = opline->opcode == ZEND_MATCH; + zend_uchar type = Z_TYPE_P(op1); + zend_bool correct_type = + (opline->opcode == ZEND_SWITCH_LONG && type == IS_LONG) + || (opline->opcode == ZEND_SWITCH_STRING && type == IS_STRING) + || (opline->opcode == ZEND_MATCH && (type == IS_LONG || type == IS_STRING)); + + if (correct_type) { zend_op_array *op_array = scdf->op_array; zend_ssa *ssa = scdf->ssa; HashTable *jmptable = Z_ARRVAL_P(CT_CONSTANT_EX(op_array, opline->op2.constant)); - zval *jmp_zv = zend_hash_index_find(jmptable, Z_LVAL_P(op1)); + zval *jmp_zv = type == IS_LONG + ? zend_hash_index_find(jmptable, Z_LVAL_P(op1)) + : zend_hash_find(jmptable, Z_STR_P(op1)); int target; if (jmp_zv) { @@ -2000,27 +2018,16 @@ static void sccp_mark_feasible_successors( } scdf_mark_edge_feasible(scdf, block_num, target); return; - } - s = 0; - break; - case ZEND_SWITCH_STRING: - if (Z_TYPE_P(op1) == IS_STRING) { + } else if (strict_comparison) { zend_op_array *op_array = scdf->op_array; zend_ssa *ssa = scdf->ssa; - HashTable *jmptable = Z_ARRVAL_P(CT_CONSTANT_EX(op_array, opline->op2.constant)); - zval *jmp_zv = zend_hash_find(jmptable, Z_STR_P(op1)); - int target; - - if (jmp_zv) { - target = ssa->cfg.map[ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, Z_LVAL_P(jmp_zv))]; - } else { - target = ssa->cfg.map[ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value)]; - } + int target = ssa->cfg.map[ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value)]; scdf_mark_edge_feasible(scdf, block_num, target); return; } s = 0; break; + } default: for (s = 0; s < block->successors_count; s++) { scdf_mark_edge_feasible(scdf, block_num, block->successors[s]); diff --git a/ext/opcache/Optimizer/zend_cfg.c b/ext/opcache/Optimizer/zend_cfg.c index 6ac5781e09dca..43b548acbb470 100644 --- a/ext/opcache/Optimizer/zend_cfg.c +++ b/ext/opcache/Optimizer/zend_cfg.c @@ -73,7 +73,11 @@ static void zend_mark_reachable(zend_op *opcodes, zend_cfg *cfg, zend_basic_bloc succ->flags |= ZEND_BB_FOLLOW; } } else { - ZEND_ASSERT(opcode == ZEND_SWITCH_LONG || opcode == ZEND_SWITCH_STRING); + ZEND_ASSERT( + opcode == ZEND_SWITCH_LONG + || opcode == ZEND_SWITCH_STRING + || opcode == ZEND_MATCH + ); if (i == b->successors_count - 1) { succ->flags |= ZEND_BB_FOLLOW | ZEND_BB_TARGET; } else { @@ -391,6 +395,7 @@ int zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, uint32_t b break; case ZEND_SWITCH_LONG: case ZEND_SWITCH_STRING: + case ZEND_MATCH: { HashTable *jumptable = Z_ARRVAL_P(CRT_CONSTANT(opline->op2)); zval *zv; @@ -557,6 +562,7 @@ int zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, uint32_t b break; case ZEND_SWITCH_LONG: case ZEND_SWITCH_STRING: + case ZEND_MATCH: { HashTable *jumptable = Z_ARRVAL_P(CRT_CONSTANT(opline->op2)); zval *zv; diff --git a/ext/opcache/Optimizer/zend_dump.c b/ext/opcache/Optimizer/zend_dump.c index dfd939f332c5a..ce23c4d473e67 100644 --- a/ext/opcache/Optimizer/zend_dump.c +++ b/ext/opcache/Optimizer/zend_dump.c @@ -615,7 +615,11 @@ void zend_dump_op(const zend_op_array *op_array, const zend_basic_block *b, cons if (opline->op2_type == IS_CONST) { zval *op = CRT_CONSTANT(opline->op2); - if (opline->opcode == ZEND_SWITCH_LONG || opline->opcode == ZEND_SWITCH_STRING) { + if ( + opline->opcode == ZEND_SWITCH_LONG + || opline->opcode == ZEND_SWITCH_STRING + || opline->opcode == ZEND_MATCH + ) { HashTable *jumptable = Z_ARRVAL_P(op); zend_string *key; zend_ulong num_key; diff --git a/ext/opcache/Optimizer/zend_inference.c b/ext/opcache/Optimizer/zend_inference.c index c4189975d5994..a1ceb5fd456d0 100644 --- a/ext/opcache/Optimizer/zend_inference.c +++ b/ext/opcache/Optimizer/zend_inference.c @@ -2413,6 +2413,7 @@ static zend_always_inline int _zend_update_type_info( case ZEND_JMPZ_EX: case ZEND_JMPNZ_EX: case ZEND_CASE: + case ZEND_CASE_STRICT: case ZEND_BOOL: case ZEND_ISSET_ISEMPTY_CV: case ZEND_ISSET_ISEMPTY_VAR: @@ -4312,6 +4313,7 @@ int zend_may_throw_ex(const zend_op *opline, const zend_ssa_op *ssa_op, const ze if (t1 & (MAY_BE_OBJECT|MAY_BE_RESOURCE|MAY_BE_ARRAY_OF_OBJECT|MAY_BE_ARRAY_OF_RESOURCE|MAY_BE_ARRAY_OF_ARRAY)) { switch (opline->opcode) { case ZEND_CASE: + case ZEND_CASE_STRICT: case ZEND_FE_FETCH_R: case ZEND_FE_FETCH_RW: case ZEND_FETCH_LIST_R: @@ -4380,6 +4382,7 @@ int zend_may_throw_ex(const zend_op *opline, const zend_ssa_op *ssa_op, const ze case ZEND_COALESCE: case ZEND_SWITCH_LONG: case ZEND_SWITCH_STRING: + case ZEND_MATCH: case ZEND_ISSET_ISEMPTY_VAR: case ZEND_ISSET_ISEMPTY_CV: case ZEND_FUNC_NUM_ARGS: @@ -4457,6 +4460,7 @@ int zend_may_throw_ex(const zend_op *opline, const zend_ssa_op *ssa_op, const ze case ZEND_IS_SMALLER: case ZEND_IS_SMALLER_OR_EQUAL: case ZEND_CASE: + case ZEND_CASE_STRICT: case ZEND_SPACESHIP: if ((t1 & MAY_BE_ANY) == MAY_BE_NULL || (t2 & MAY_BE_ANY) == MAY_BE_NULL) { diff --git a/ext/opcache/Optimizer/zend_optimizer.c b/ext/opcache/Optimizer/zend_optimizer.c index 8456c46078fd4..78b5893b2f406 100644 --- a/ext/opcache/Optimizer/zend_optimizer.c +++ b/ext/opcache/Optimizer/zend_optimizer.c @@ -293,6 +293,7 @@ int zend_optimizer_update_op1_const(zend_op_array *op_array, * zend_optimizer_replace_by_const() supports this. */ return 0; case ZEND_CASE: + case ZEND_CASE_STRICT: case ZEND_FETCH_LIST_R: case ZEND_COPY_TMP: case ZEND_FETCH_CLASS_NAME: @@ -558,7 +559,7 @@ int zend_optimizer_replace_by_const(zend_op_array *op_array, break; /* In most cases IS_TMP_VAR operand may be used only once. * The operands are usually destroyed by the opcode handler. - * ZEND_CASE and ZEND_FETCH_LIST_R are exceptions, they keeps operand + * ZEND_CASE[_STRICT] and ZEND_FETCH_LIST_R are exceptions, they keeps operand * unchanged, and allows its reuse. these instructions * usually terminated by ZEND_FREE that finally kills the value. */ @@ -587,17 +588,25 @@ int zend_optimizer_replace_by_const(zend_op_array *op_array, } case ZEND_SWITCH_LONG: case ZEND_SWITCH_STRING: - case ZEND_CASE: { + case ZEND_MATCH: + case ZEND_CASE: + case ZEND_CASE_STRICT: { zend_op *end = op_array->opcodes + op_array->last; while (opline < end) { if (opline->op1_type == type && opline->op1.var == var) { - if (opline->opcode == ZEND_CASE - || opline->opcode == ZEND_SWITCH_LONG - || opline->opcode == ZEND_SWITCH_STRING) { + if ( + opline->opcode == ZEND_CASE + || opline->opcode == ZEND_CASE_STRICT + || opline->opcode == ZEND_SWITCH_LONG + || opline->opcode == ZEND_SWITCH_STRING + || opline->opcode == ZEND_MATCH + ) { zval v; if (opline->opcode == ZEND_CASE) { opline->opcode = ZEND_IS_EQUAL; + } else if (opline->opcode == ZEND_CASE_STRICT) { + opline->opcode = ZEND_IS_IDENTICAL; } ZVAL_COPY(&v, val); if (Z_TYPE(v) == IS_STRING) { @@ -687,6 +696,7 @@ void zend_optimizer_migrate_jump(zend_op_array *op_array, zend_op *new_opline, z break; case ZEND_SWITCH_LONG: case ZEND_SWITCH_STRING: + case ZEND_MATCH: { HashTable *jumptable = Z_ARRVAL(ZEND_OP2_LITERAL(opline)); zval *zv; @@ -731,6 +741,7 @@ void zend_optimizer_shift_jump(zend_op_array *op_array, zend_op *opline, uint32_ break; case ZEND_SWITCH_LONG: case ZEND_SWITCH_STRING: + case ZEND_MATCH: { HashTable *jumptable = Z_ARRVAL(ZEND_OP2_LITERAL(opline)); zval *zv; @@ -1105,6 +1116,7 @@ static void zend_redo_pass_two(zend_op_array *op_array) case ZEND_FE_FETCH_RW: case ZEND_SWITCH_LONG: case ZEND_SWITCH_STRING: + case ZEND_MATCH: /* relative extended_value don't have to be changed */ break; #endif @@ -1115,6 +1127,7 @@ static void zend_redo_pass_two(zend_op_array *op_array) case ZEND_IS_SMALLER: case ZEND_IS_SMALLER_OR_EQUAL: case ZEND_CASE: + case ZEND_CASE_STRICT: case ZEND_ISSET_ISEMPTY_CV: case ZEND_ISSET_ISEMPTY_VAR: case ZEND_ISSET_ISEMPTY_DIM_OBJ: @@ -1225,6 +1238,7 @@ static void zend_redo_pass_two_ex(zend_op_array *op_array, zend_ssa *ssa) case ZEND_FE_FETCH_RW: case ZEND_SWITCH_LONG: case ZEND_SWITCH_STRING: + case ZEND_MATCH: /* relative extended_value don't have to be changed */ break; #endif @@ -1235,6 +1249,7 @@ static void zend_redo_pass_two_ex(zend_op_array *op_array, zend_ssa *ssa) case ZEND_IS_SMALLER: case ZEND_IS_SMALLER_OR_EQUAL: case ZEND_CASE: + case ZEND_CASE_STRICT: case ZEND_ISSET_ISEMPTY_CV: case ZEND_ISSET_ISEMPTY_VAR: case ZEND_ISSET_ISEMPTY_DIM_OBJ: diff --git a/ext/opcache/jit/zend_jit.c b/ext/opcache/jit/zend_jit.c index 8c46cf9676a98..34bc928407cbb 100644 --- a/ext/opcache/jit/zend_jit.c +++ b/ext/opcache/jit/zend_jit.c @@ -2120,7 +2120,8 @@ static int zend_jit(const zend_op_array *op_array, zend_ssa *ssa, const zend_op && ssa->cfg.blocks[b].start != 0 && (op_array->opcodes[ssa->cfg.blocks[b].start - 1].opcode == ZEND_NOP || op_array->opcodes[ssa->cfg.blocks[b].start - 1].opcode == ZEND_SWITCH_LONG - || op_array->opcodes[ssa->cfg.blocks[b].start - 1].opcode == ZEND_SWITCH_STRING)) { + || op_array->opcodes[ssa->cfg.blocks[b].start - 1].opcode == ZEND_SWITCH_STRING + || op_array->opcodes[ssa->cfg.blocks[b].start - 1].opcode == ZEND_MATCH)) { if (!zend_jit_reset_opline(&dasm_state, op_array->opcodes + ssa->cfg.blocks[b].start) || !zend_jit_set_valid_ip(&dasm_state, op_array->opcodes + ssa->cfg.blocks[b].start)) { goto jit_failure; @@ -2851,6 +2852,7 @@ static int zend_jit(const zend_op_array *op_array, zend_ssa *ssa, const zend_op goto done; case ZEND_SWITCH_LONG: case ZEND_SWITCH_STRING: + case ZEND_MATCH: if (!zend_jit_switch(&dasm_state, opline, op_array, ssa)) { goto jit_failure; } @@ -2898,6 +2900,7 @@ static int zend_jit(const zend_op_array *op_array, zend_ssa *ssa, const zend_op case ZEND_OP_DATA: case ZEND_SWITCH_LONG: case ZEND_SWITCH_STRING: + case ZEND_MATCH: break; case ZEND_JMP: if (JIT_G(opt_level) < ZEND_JIT_LEVEL_INLINE) { diff --git a/ext/opcache/jit/zend_jit_trace.c b/ext/opcache/jit/zend_jit_trace.c index 8bbd3debeebc5..341a90b6fbfd2 100644 --- a/ext/opcache/jit/zend_jit_trace.c +++ b/ext/opcache/jit/zend_jit_trace.c @@ -279,6 +279,7 @@ static int zend_jit_trace_may_exit(const zend_op_array *op_array, const zend_op case ZEND_FE_FETCH_RW: case ZEND_SWITCH_LONG: case ZEND_SWITCH_STRING: + case ZEND_MATCH: /* branch opcodes */ return 1; case ZEND_NEW: @@ -3943,6 +3944,7 @@ static const void *zend_jit_trace(zend_jit_trace_rec *trace_buffer, uint32_t par #if 0 case ZEND_SWITCH_LONG: case ZEND_SWITCH_STRING: + case ZEND_MATCH: if (!zend_jit_switch(&dasm_state, opline, op_array, op_array_ssa)) { goto jit_failure; } diff --git a/ext/opcache/jit/zend_jit_x86.dasc b/ext/opcache/jit/zend_jit_x86.dasc index cfd3b0f4cbaea..46145a83bb646 100644 --- a/ext/opcache/jit/zend_jit_x86.dasc +++ b/ext/opcache/jit/zend_jit_x86.dasc @@ -11377,6 +11377,13 @@ static int zend_jit_switch(dasm_State **Dst, const zend_op *opline, const zend_o { HashTable *jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2)); + // TODO: Implement for match instructions + if (opline->opcode == ZEND_MATCH) { + // Since the match expression doesn't have a IS_IDENTICAL/JMPNZ chain + // we can't skip the jumptable and thus can't JIT the function + return 0; + } + if (opline->op1_type == IS_CONST) { zval *zv = RT_CONSTANT(opline, opline->op1); zval *jump_zv; diff --git a/ext/opcache/tests/match/001.phpt b/ext/opcache/tests/match/001.phpt new file mode 100644 index 0000000000000..172808fe4117d --- /dev/null +++ b/ext/opcache/tests/match/001.phpt @@ -0,0 +1,75 @@ +--TEST-- +Match expression string jump table +--INI-- +opcache.enable=1 +opcache.enable_cli=1 +opcache.opt_debug_level=0x20000 +--SKIPIF-- + +--FILE-- + 'a', + 'b', 'c' => 'b, c', + 'd' => 'd', + 'e', 'f' => 'e, f', + 'g' => 'g', + 'h', 'i' => 'h, i', + }; +} + +foreach (range('a', 'i') as $char) { + var_dump(test($char)); +} + +--EXPECTF-- +$_main: + ; (lines=15, args=0, vars=1, tmps=2) + ; (after optimizer) + ; %s +0000 INIT_FCALL 2 %d string("range") +0001 SEND_VAL string("a") 1 +0002 SEND_VAL string("i") 2 +0003 V2 = DO_ICALL +0004 V1 = FE_RESET_R V2 0013 +0005 FE_FETCH_R V1 CV0($char) 0013 +0006 INIT_FCALL 1 %d string("var_dump") +0007 INIT_FCALL 1 %d string("test") +0008 SEND_VAR CV0($char) 1 +0009 V2 = DO_UCALL +0010 SEND_VAR V2 1 +0011 DO_ICALL +0012 JMP 0005 +0013 FE_FREE V1 +0014 RETURN int(1) +LIVE RANGES: + 1: 0005 - 0013 (loop) + +test: + ; (lines=11, args=1, vars=1, tmps=1) + ; (after optimizer) + ; %s +0000 CV0($char) = RECV 1 +0001 MATCH CV0($char) "a": 0002, "b": 0003, "c": 0003, "d": 0004, "e": 0005, "f": 0005, "g": 0006, "h": 0007, "i": 0007, default: 0008 +0002 RETURN string("a") +0003 RETURN string("b, c") +0004 RETURN string("d") +0005 RETURN string("e, f") +0006 RETURN string("g") +0007 RETURN string("h, i") +0008 V1 = NEW 0 string("UnhandledMatchError") +0009 DO_FCALL +0010 THROW V1 +LIVE RANGES: + 1: 0009 - 0010 (new) +string(1) "a" +string(4) "b, c" +string(4) "b, c" +string(1) "d" +string(4) "e, f" +string(4) "e, f" +string(1) "g" +string(4) "h, i" +string(4) "h, i" diff --git a/ext/opcache/tests/match/002.phpt b/ext/opcache/tests/match/002.phpt new file mode 100644 index 0000000000000..22f29eeb8b2d0 --- /dev/null +++ b/ext/opcache/tests/match/002.phpt @@ -0,0 +1,57 @@ +--TEST-- +Test match jump table optimizer +--INI-- +opcache.enable=1 +opcache.enable_cli=1 +opcache.opt_debug_level=0x20000 +--SKIPIF-- + +--FILE-- + throw new RuntimeException(), + default => "No match\n", + }; +} +test(); + +function test2() { + $x = 2; + echo match($x) { + '1', '2', '3', '4', '5' => throw new RuntimeException(), + default => "No match\n", + }; +} +test2(); + +--EXPECTF-- +$_main: + ; (lines=5, args=0, vars=0, tmps=0) + ; (after optimizer) + ; %s +0000 INIT_FCALL 0 %d string("test") +0001 DO_UCALL +0002 INIT_FCALL 0 %d string("test2") +0003 DO_UCALL +0004 RETURN int(1) + +test: + ; (lines=2, args=0, vars=0, tmps=0) + ; (after optimizer) + ; %s +0000 ECHO string("No match +") +0001 RETURN null + +test2: + ; (lines=2, args=0, vars=0, tmps=0) + ; (after optimizer) + ; %s +0000 ECHO string("No match +") +0001 RETURN null +No match +No match diff --git a/ext/opcache/tests/match/003.phpt b/ext/opcache/tests/match/003.phpt new file mode 100644 index 0000000000000..f7f8896073286 --- /dev/null +++ b/ext/opcache/tests/match/003.phpt @@ -0,0 +1,74 @@ +--TEST-- +Match expression long jump table +--INI-- +opcache.enable=1 +opcache.enable_cli=1 +opcache.opt_debug_level=0x20000 +--SKIPIF-- + +--FILE-- + '1', + 2, 3 => '2, 3', + 4 => '4', + 5, 6 => '5, 6', + 7 => '7', + 8, 9 => '8, 9', + default => 'default' + }; +} + +foreach (range(0, 10) as $char) { + var_dump(test($char)); +} + +--EXPECTF-- +$_main: + ; (lines=15, args=0, vars=1, tmps=2) + ; (after optimizer) + ; %s +0000 INIT_FCALL 2 %d string("range") +0001 SEND_VAL int(0) 1 +0002 SEND_VAL int(10) 2 +0003 V2 = DO_ICALL +0004 V1 = FE_RESET_R V2 0013 +0005 FE_FETCH_R V1 CV0($char) 0013 +0006 INIT_FCALL 1 %d string("var_dump") +0007 INIT_FCALL 1 %d string("test") +0008 SEND_VAR CV0($char) 1 +0009 V2 = DO_UCALL +0010 SEND_VAR V2 1 +0011 DO_ICALL +0012 JMP 0005 +0013 FE_FREE V1 +0014 RETURN int(1) +LIVE RANGES: + 1: 0005 - 0013 (loop) + +test: + ; (lines=9, args=1, vars=1, tmps=0) + ; (after optimizer) + ; %s +0000 CV0($char) = RECV 1 +0001 MATCH CV0($char) 1: 0002, 2: 0003, 3: 0003, 4: 0004, 5: 0005, 6: 0005, 7: 0006, 8: 0007, 9: 0007, default: 0008 +0002 RETURN string("1") +0003 RETURN string("2, 3") +0004 RETURN string("4") +0005 RETURN string("5, 6") +0006 RETURN string("7") +0007 RETURN string("8, 9") +0008 RETURN string("default") +string(7) "default" +string(1) "1" +string(4) "2, 3" +string(4) "2, 3" +string(1) "4" +string(4) "5, 6" +string(4) "5, 6" +string(1) "7" +string(4) "8, 9" +string(4) "8, 9" +string(7) "default" diff --git a/ext/opcache/tests/match/004.phpt b/ext/opcache/tests/match/004.phpt new file mode 100644 index 0000000000000..f84a0b832d948 --- /dev/null +++ b/ext/opcache/tests/match/004.phpt @@ -0,0 +1,93 @@ +--TEST-- +Match expression mixed jump table +--INI-- +opcache.enable=1 +opcache.enable_cli=1 +opcache.opt_debug_level=0x20000 +--SKIPIF-- + +--FILE-- + '1 int', + '1' => '1 string', + 2 => '2 int', + '2' => '2 string', + 3 => '3 int', + '3' => '3 string', + 4 => '4 int', + '4' => '4 string', + 5 => '5 int', + '5' => '5 string', + default => 'default', + }; +} + +foreach (range(0, 6) as $number) { + var_dump(test($number)); + var_dump(test((string) $number)); +} + +--EXPECTF-- +$_main: + ; (lines=22, args=0, vars=1, tmps=2) + ; (after optimizer) + ; %s.php:1-24 +0000 INIT_FCALL 2 %d string("range") +0001 SEND_VAL int(0) 1 +0002 SEND_VAL int(6) 2 +0003 V2 = DO_ICALL +0004 V1 = FE_RESET_R V2 0020 +0005 FE_FETCH_R V1 CV0($number) 0020 +0006 INIT_FCALL 1 %d string("var_dump") +0007 INIT_FCALL 1 %d string("test") +0008 SEND_VAR CV0($number) 1 +0009 V2 = DO_UCALL +0010 SEND_VAR V2 1 +0011 DO_ICALL +0012 INIT_FCALL 1 %d string("var_dump") +0013 INIT_FCALL 1 %d string("test") +0014 T2 = CAST (string) CV0($number) +0015 SEND_VAL T2 1 +0016 V2 = DO_UCALL +0017 SEND_VAR V2 1 +0018 DO_ICALL +0019 JMP 0005 +0020 FE_FREE V1 +0021 RETURN int(1) +LIVE RANGES: + 1: 0005 - 0020 (loop) + +test: + ; (lines=13, args=1, vars=1, tmps=0) + ; (after optimizer) + ; %s.php:3-17 +0000 CV0($value) = RECV 1 +0001 MATCH CV0($value) 1: 0002, "1": 0003, 2: 0004, "2": 0005, 3: 0006, "3": 0007, 4: 0008, "4": 0009, 5: 0010, "5": 0011, default: 0012 +0002 RETURN string("1 int") +0003 RETURN string("1 string") +0004 RETURN string("2 int") +0005 RETURN string("2 string") +0006 RETURN string("3 int") +0007 RETURN string("3 string") +0008 RETURN string("4 int") +0009 RETURN string("4 string") +0010 RETURN string("5 int") +0011 RETURN string("5 string") +0012 RETURN string("default") +string(7) "default" +string(7) "default" +string(5) "1 int" +string(8) "1 string" +string(5) "2 int" +string(8) "2 string" +string(5) "3 int" +string(8) "3 string" +string(5) "4 int" +string(8) "4 string" +string(5) "5 int" +string(8) "5 string" +string(7) "default" +string(7) "default" diff --git a/ext/opcache/zend_file_cache.c b/ext/opcache/zend_file_cache.c index 15ade4ce3c079..379f3fa9a1d22 100644 --- a/ext/opcache/zend_file_cache.c +++ b/ext/opcache/zend_file_cache.c @@ -547,6 +547,7 @@ static void zend_file_cache_serialize_op_array(zend_op_array *op_arra case ZEND_FE_FETCH_RW: case ZEND_SWITCH_LONG: case ZEND_SWITCH_STRING: + case ZEND_MATCH: /* relative extended_value don't have to be changed */ break; } diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c index ae997b9a60907..e6b5194bfeb10 100644 --- a/ext/opcache/zend_persist.c +++ b/ext/opcache/zend_persist.c @@ -549,6 +549,7 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc case ZEND_FE_FETCH_RW: case ZEND_SWITCH_LONG: case ZEND_SWITCH_STRING: + case ZEND_MATCH: /* relative extended_value don't have to be changed */ break; } diff --git a/ext/standard/tests/file/fnmatch_variation.phpt b/ext/standard/tests/file/fnmatch_variation.phpt index e7ad22244447a..4ca81ed94fd0e 100644 --- a/ext/standard/tests/file/fnmatch_variation.phpt +++ b/ext/standard/tests/file/fnmatch_variation.phpt @@ -74,7 +74,7 @@ unlink($file_name); echo "\n*** Testing fnmatch() with other types other than files ***"; /* defining a common function */ -function match( $pattern, $string ) { +function match_( $pattern, $string ) { for( $i = 0; $i diff --git a/ext/tokenizer/tokenizer_data.c b/ext/tokenizer/tokenizer_data.c index 9c7df932076ce..14630cdd4014c 100644 --- a/ext/tokenizer/tokenizer_data.c +++ b/ext/tokenizer/tokenizer_data.c @@ -84,8 +84,6 @@ void tokenizer_register_constants(INIT_FUNC_ARGS) { REGISTER_LONG_CONSTANT("T_STRING_VARNAME", T_STRING_VARNAME, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_NUM_STRING", T_NUM_STRING, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_EVAL", T_EVAL, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("T_INC", T_INC, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("T_DEC", T_DEC, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_NEW", T_NEW, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_EXIT", T_EXIT, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_IF", T_IF, CONST_CS | CONST_PERSISTENT); @@ -105,6 +103,7 @@ void tokenizer_register_constants(INIT_FUNC_ARGS) { REGISTER_LONG_CONSTANT("T_ENDSWITCH", T_ENDSWITCH, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_CASE", T_CASE, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_DEFAULT", T_DEFAULT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("T_MATCH", T_MATCH, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_BREAK", T_BREAK, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_CONTINUE", T_CONTINUE, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_GOTO", T_GOTO, CONST_CS | CONST_PERSISTENT); @@ -134,7 +133,7 @@ void tokenizer_register_constants(INIT_FUNC_ARGS) { REGISTER_LONG_CONSTANT("T_INTERFACE", T_INTERFACE, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_EXTENDS", T_EXTENDS, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_IMPLEMENTS", T_IMPLEMENTS, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("T_OBJECT_OPERATOR", T_OBJECT_OPERATOR, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("T_NAMESPACE", T_NAMESPACE, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_LIST", T_LIST, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_ARRAY", T_ARRAY, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_CALLABLE", T_CALLABLE, CONST_CS | CONST_PERSISTENT); @@ -145,6 +144,10 @@ void tokenizer_register_constants(INIT_FUNC_ARGS) { REGISTER_LONG_CONSTANT("T_TRAIT_C", T_TRAIT_C, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_METHOD_C", T_METHOD_C, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_FUNC_C", T_FUNC_C, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("T_NS_C", T_NS_C, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("T_INC", T_INC, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("T_DEC", T_DEC, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("T_OBJECT_OPERATOR", T_OBJECT_OPERATOR, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_COMMENT", T_COMMENT, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_DOC_COMMENT", T_DOC_COMMENT, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_OPEN_TAG", T_OPEN_TAG, CONST_CS | CONST_PERSISTENT); @@ -156,8 +159,6 @@ void tokenizer_register_constants(INIT_FUNC_ARGS) { REGISTER_LONG_CONSTANT("T_DOLLAR_OPEN_CURLY_BRACES", T_DOLLAR_OPEN_CURLY_BRACES, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_CURLY_OPEN", T_CURLY_OPEN, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_PAAMAYIM_NEKUDOTAYIM", T_PAAMAYIM_NEKUDOTAYIM, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("T_NAMESPACE", T_NAMESPACE, CONST_CS | CONST_PERSISTENT); - REGISTER_LONG_CONSTANT("T_NS_C", T_NS_C, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_NS_SEPARATOR", T_NS_SEPARATOR, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_ELLIPSIS", T_ELLIPSIS, CONST_CS | CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_BAD_CHARACTER", T_BAD_CHARACTER, CONST_CS | CONST_PERSISTENT); @@ -227,8 +228,6 @@ char *get_token_type_name(int token_type) case T_STRING_VARNAME: return "T_STRING_VARNAME"; case T_NUM_STRING: return "T_NUM_STRING"; case T_EVAL: return "T_EVAL"; - case T_INC: return "T_INC"; - case T_DEC: return "T_DEC"; case T_NEW: return "T_NEW"; case T_EXIT: return "T_EXIT"; case T_IF: return "T_IF"; @@ -248,6 +247,7 @@ char *get_token_type_name(int token_type) case T_ENDSWITCH: return "T_ENDSWITCH"; case T_CASE: return "T_CASE"; case T_DEFAULT: return "T_DEFAULT"; + case T_MATCH: return "T_MATCH"; case T_BREAK: return "T_BREAK"; case T_CONTINUE: return "T_CONTINUE"; case T_GOTO: return "T_GOTO"; @@ -277,7 +277,7 @@ char *get_token_type_name(int token_type) case T_INTERFACE: return "T_INTERFACE"; case T_EXTENDS: return "T_EXTENDS"; case T_IMPLEMENTS: return "T_IMPLEMENTS"; - case T_OBJECT_OPERATOR: return "T_OBJECT_OPERATOR"; + case T_NAMESPACE: return "T_NAMESPACE"; case T_LIST: return "T_LIST"; case T_ARRAY: return "T_ARRAY"; case T_CALLABLE: return "T_CALLABLE"; @@ -288,6 +288,10 @@ char *get_token_type_name(int token_type) case T_TRAIT_C: return "T_TRAIT_C"; case T_METHOD_C: return "T_METHOD_C"; case T_FUNC_C: return "T_FUNC_C"; + case T_NS_C: return "T_NS_C"; + case T_INC: return "T_INC"; + case T_DEC: return "T_DEC"; + case T_OBJECT_OPERATOR: return "T_OBJECT_OPERATOR"; case T_COMMENT: return "T_COMMENT"; case T_DOC_COMMENT: return "T_DOC_COMMENT"; case T_OPEN_TAG: return "T_OPEN_TAG"; @@ -299,8 +303,6 @@ char *get_token_type_name(int token_type) case T_DOLLAR_OPEN_CURLY_BRACES: return "T_DOLLAR_OPEN_CURLY_BRACES"; case T_CURLY_OPEN: return "T_CURLY_OPEN"; case T_PAAMAYIM_NEKUDOTAYIM: return "T_DOUBLE_COLON"; - case T_NAMESPACE: return "T_NAMESPACE"; - case T_NS_C: return "T_NS_C"; case T_NS_SEPARATOR: return "T_NS_SEPARATOR"; case T_ELLIPSIS: return "T_ELLIPSIS"; case T_BAD_CHARACTER: return "T_BAD_CHARACTER"; From 7e2b0a44fe977412d7df87a797c236c6e88b5cde Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Tue, 7 Jul 2020 19:24:42 +0200 Subject: [PATCH 02/14] Fix usage of incorrect var in test --- Zend/tests/match/027.phpt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Zend/tests/match/027.phpt b/Zend/tests/match/027.phpt index 2f1ce21984f32..788f5d60393b0 100644 --- a/Zend/tests/match/027.phpt +++ b/Zend/tests/match/027.phpt @@ -20,7 +20,7 @@ function main() { Test::usesValue(match(true) { true => $i }); echo "i is $i\n"; $j = 1; - Test::usesRef(match(true) { true => $i }); + Test::usesRef(match(true) { true => $j }); echo "j is $j\n"; } main(); From 2ed10c4ab1cf8a3c2e07193ef2673a3bb2b53adc Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Tue, 7 Jul 2020 19:25:12 +0200 Subject: [PATCH 03/14] Unnecessary EXPECTF --- Zend/tests/match/011.phpt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Zend/tests/match/011.phpt b/Zend/tests/match/011.phpt index 7af3ead5dad2d..1c3c139ef7255 100644 --- a/Zend/tests/match/011.phpt +++ b/Zend/tests/match/011.phpt @@ -14,6 +14,6 @@ var_dump(match ('foo') { }); ?> ---EXPECTF-- +--EXPECT-- string(3) "foo" string(3) "foo" From 8f75297b492a2b5c161a9858660b418e9aba4efa Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Tue, 7 Jul 2020 22:39:57 +0200 Subject: [PATCH 04/14] Improve unhandled match error message --- Zend/tests/match/006.phpt | 2 +- Zend/tests/match/007.phpt | 2 +- Zend/tests/match/037.phpt | 6 +- Zend/tests/match/043.phpt | 39 ++ Zend/zend.c | 47 ++ Zend/zend.h | 1 + Zend/zend_compile.c | 11 +- Zend/zend_vm_def.h | 19 + Zend/zend_vm_execute.h | 143 +++-- Zend/zend_vm_handlers.h | 914 ++++++++++++++++--------------- Zend/zend_vm_opcodes.c | 6 +- Zend/zend_vm_opcodes.h | 3 +- ext/opcache/Optimizer/dce.c | 1 + ext/opcache/Optimizer/pass1.c | 1 + ext/opcache/Optimizer/zend_cfg.c | 2 + ext/opcache/jit/zend_jit.c | 1 + ext/opcache/jit/zend_jit_trace.c | 1 + 17 files changed, 683 insertions(+), 516 deletions(-) create mode 100644 Zend/tests/match/043.phpt diff --git a/Zend/tests/match/006.phpt b/Zend/tests/match/006.phpt index 63d8056143876..9ab998eee3b23 100644 --- a/Zend/tests/match/006.phpt +++ b/Zend/tests/match/006.phpt @@ -7,7 +7,7 @@ $x = match (true) {}; ?> --EXPECTF-- -Fatal error: Uncaught UnhandledMatchError in %s +Fatal error: Uncaught UnhandledMatchError: Unhandled match value true in %s Stack trace: #0 {main} thrown in %s on line %d diff --git a/Zend/tests/match/007.phpt b/Zend/tests/match/007.phpt index 35095975a9c50..3fdc5dca2f5d2 100644 --- a/Zend/tests/match/007.phpt +++ b/Zend/tests/match/007.phpt @@ -19,7 +19,7 @@ echo get_value(3) . "\n"; 1 2 -Fatal error: Uncaught UnhandledMatchError in %s +Fatal error: Uncaught UnhandledMatchError: Unhandled match value 3 in %s Stack trace: #0 %s: get_value(3) #1 {main} diff --git a/Zend/tests/match/037.phpt b/Zend/tests/match/037.phpt index 40dbe4768a7a8..a29d52025dd8e 100644 --- a/Zend/tests/match/037.phpt +++ b/Zend/tests/match/037.phpt @@ -52,13 +52,13 @@ var_dump(match(3) { }); --EXPECTF-- -string(%d) "UnhandledMatchError in %s037.php:5 +string(%d) "UnhandledMatchError: Unhandled match value true in %s037.php:5 Stack trace: #0 {main}" -string(%d) "UnhandledMatchError in %s037.php:13 +string(%d) "UnhandledMatchError: Unhandled match value 6 in %s037.php:13 Stack trace: #0 {main}" -string(%d) "UnhandledMatchError in %s037.php:21 +string(%d) "UnhandledMatchError: Unhandled match value "3" in %s037.php:21 Stack trace: #0 {main}" string(3) "foo" diff --git a/Zend/tests/match/043.phpt b/Zend/tests/match/043.phpt new file mode 100644 index 0000000000000..84e5a38553a31 --- /dev/null +++ b/Zend/tests/match/043.phpt @@ -0,0 +1,39 @@ +--TEST-- +Match expression error message +--FILE-- +getMessage() . "\n"; + } +} + +test($a); +test([]); +test((object) []); +test(fopen('php://stdout', 'w')); +test(null); +test(false); +test(true); +test(42); +test(pi()); +test("Foo bar"); +test("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas pretium ante tellus, a molestie sapien commodo sed. Nulla pellentesque nulla eget tellus fringilla tristique."); + +?> +--EXPECTF-- +Warning: Undefined variable $a in %s.php on line 11 +Unhandled match value null +Unhandled match value of type array +Unhandled match value of type stdClass +Unhandled match value of type resource +Unhandled match value null +Unhandled match value false +Unhandled match value true +Unhandled match value 42 +Unhandled match value 3.1415926535898 +Unhandled match value "Foo bar" +Unhandled match value "Lorem ipsum dolor si..." diff --git a/Zend/zend.c b/Zend/zend.c index 2765f8c3ead22..7ff32c5a1cd01 100644 --- a/Zend/zend.c +++ b/Zend/zend.c @@ -66,6 +66,7 @@ static char *zend_version_info; static uint32_t zend_version_info_length; #define ZEND_CORE_VERSION_INFO "Zend Engine v" ZEND_VERSION ", Copyright (c) Zend Technologies\n" #define PRINT_ZVAL_INDENT 4 +#define READABLE_ZVAL_MAX_STR_LENGTH 20 /* true multithread-shared globals */ ZEND_API zend_class_entry *zend_standard_class_def = NULL; @@ -502,6 +503,52 @@ ZEND_API void zend_print_zval_r(zval *expr, int indent) /* {{{ */ } /* }}} */ +ZEND_API zend_string *zend_zval_to_readable_string(zval *expr) +{ +try_again: + switch (Z_TYPE_P(expr)) { + case IS_UNDEF: + case IS_ARRAY: + case IS_OBJECT: + case IS_RESOURCE: + return NULL; + case IS_NULL: + return zend_string_init("null", strlen("null"), 0); + case IS_FALSE: + return zend_string_init("false", strlen("false"), 0); + case IS_TRUE: + return zend_string_init("true", strlen("true"), 0); + case IS_LONG: + return zend_long_to_str(Z_LVAL_P(expr)); + case IS_DOUBLE: + return zend_strpprintf_unchecked(0, "%.*H", (int) EG(precision), Z_DVAL_P(expr)); + case IS_STRING: { + zend_string *str = Z_STR_P(expr); + size_t str_len = ZSTR_LEN(str); + smart_str readable_str = {0}; + smart_str_appendc(&readable_str, '"'); + if (str_len <= READABLE_ZVAL_MAX_STR_LENGTH) { + smart_str_appends(&readable_str, ZSTR_VAL(str)); + } else { + // FIXME: Doesn't handle multi byte strings + zend_string *truncated_str = zend_string_init_fast(ZSTR_VAL(str), READABLE_ZVAL_MAX_STR_LENGTH); + // FIXME: Doesn't handle escaping of special chars (namely " and \) + smart_str_appends(&readable_str, ZSTR_VAL(truncated_str)); + zend_string_release_ex(truncated_str, 0); + smart_str_appends(&readable_str, "..."); + } + smart_str_appendc(&readable_str, '"'); + smart_str_0(&readable_str); + return readable_str.s; + } + case IS_REFERENCE: + expr = Z_REFVAL_P(expr); + goto try_again; + EMPTY_SWITCH_DEFAULT_CASE() + } + return NULL; +} + static FILE *zend_fopen_wrapper(const char *filename, zend_string **opened_path) /* {{{ */ { if (opened_path) { diff --git a/Zend/zend.h b/Zend/zend.h index 4fe89fcacc809..bbbeb79aea202 100644 --- a/Zend/zend.h +++ b/Zend/zend.h @@ -251,6 +251,7 @@ ZEND_API size_t zend_print_zval(zval *expr, int indent); ZEND_API void zend_print_zval_r(zval *expr, int indent); ZEND_API zend_string *zend_print_zval_r_to_str(zval *expr, int indent); ZEND_API void zend_print_flat_zval_r(zval *expr); +ZEND_API zend_string *zend_zval_to_readable_string(zval *expr); #define zend_print_variable(var) \ zend_print_zval((var), 0) diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 5ee40879d3b47..1bcfda8f37c1f 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -5368,16 +5368,7 @@ void zend_compile_match(znode *result, zend_ast *ast) /* {{{ */ opline->extended_value = get_next_op_number(); } - zval error_name; - ZVAL_STRING(&error_name, "UnhandledMatchError"); - zend_ast *error_name_ast = zend_ast_create_zval(&error_name); - - zend_ast *error_args_ast = zend_ast_create_list(0, ZEND_AST_ARG_LIST); - zend_ast *new_error_ast = zend_ast_create(ZEND_AST_NEW, error_name_ast, error_args_ast); - zend_ast *throw_ast = zend_ast_create(ZEND_AST_THROW, new_error_ast); - zend_compile_throw(NULL, throw_ast); - - zval_ptr_dtor(&error_name); + zend_emit_op(NULL, ZEND_MATCH_ERROR, &expr_node, NULL); } for (uint32_t i = 0; i < arms->children; ++i) { diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 5f11090eae056..39b40f2f9e432 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -8446,6 +8446,25 @@ ZEND_VM_C_LABEL(default_branch): } } +ZEND_VM_COLD_CONST_HANDLER(197, ZEND_MATCH_ERROR, CONST|TMPVARCV, UNUSED) +{ + USE_OPLINE + zval *op; + zend_string *zval_str; + + op = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R); + zval_str = zend_zval_to_readable_string(op); + + if (zval_str != NULL) { + zend_throw_exception_ex(zend_ce_unhandled_match_error, 0, "Unhandled match value %s", ZSTR_VAL(zval_str)); + zend_string_release_ex(zval_str, 0); + } else { + zend_throw_exception_ex(zend_ce_unhandled_match_error, 0, "Unhandled match value of type %s", zend_zval_type_name(op)); + } + + HANDLE_EXCEPTION(); +} + ZEND_VM_COLD_CONSTCONST_HANDLER(189, ZEND_IN_ARRAY, CONST|TMP|VAR|CV, CONST, NUM) { USE_OPLINE diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 9fbf240c54290..a63df8f4c5a6b 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -9275,6 +9275,25 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_UNUSED_HANDLE ZEND_VM_RETURN(); } +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op; + zend_string *zval_str; + + op = RT_CONSTANT(opline, opline->op1); + zval_str = zend_zval_to_readable_string(op); + + if (zval_str != NULL) { + zend_throw_exception_ex(zend_ce_unhandled_match_error, 0, "Unhandled match value %s", ZSTR_VAL(zval_str)); + zend_string_release_ex(zval_str, 0); + } else { + zend_throw_exception_ex(zend_ce_unhandled_match_error, 0, "Unhandled match value of type %s", zend_zval_type_name(op)); + } + + HANDLE_EXCEPTION(); +} + static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -12742,6 +12761,25 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMP ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op; + zend_string *zval_str; + + op = EX_VAR(opline->op1.var); + zval_str = zend_zval_to_readable_string(op); + + if (zval_str != NULL) { + zend_throw_exception_ex(zend_ce_unhandled_match_error, 0, "Unhandled match value %s", ZSTR_VAL(zval_str)); + zend_string_release_ex(zval_str, 0); + } else { + zend_throw_exception_ex(zend_ce_unhandled_match_error, 0, "Unhandled match value of type %s", zend_zval_type_name(op)); + } + + HANDLE_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -51056,6 +51094,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_LABEL, + (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL, + (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL, (void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL, (void*)&&ZEND_JMP_FORWARD_SPEC_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -52972,6 +53015,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_YIELD_SPEC_CONST_UNUSED) ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_MATCH_ERROR_SPEC_CONST_UNUSED): + VM_TRACE(ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) + ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_COUNT_SPEC_CONST_UNUSED): VM_TRACE(ZEND_COUNT_SPEC_CONST_UNUSED) ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -53492,6 +53539,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) VM_TRACE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED): + VM_TRACE(ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) + ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV): VM_TRACE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -58670,6 +58721,11 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, + ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER, + ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER, + ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER, + ZEND_NULL_HANDLER, + ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER, ZEND_RECV_NOTYPE_SPEC_HANDLER, ZEND_JMP_FORWARD_SPEC_HANDLER, ZEND_NULL_HANDLER, @@ -59773,7 +59829,8 @@ void zend_vm_init(void) 2290 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 2315 | SPEC_RULE_OP1, 2320 | SPEC_RULE_OP1 | SPEC_RULE_OP2, - 3248 + 2345 | SPEC_RULE_OP1, + 3253 }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -59938,7 +59995,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 = 2347 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2352 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -59946,7 +60003,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 = 2372 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2377 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -59954,7 +60011,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 = 2397 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2402 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -59965,17 +60022,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 = 2422 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2427 | 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 = 2447 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2452 | 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 = 2472 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2477 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -59986,17 +60043,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 = 2497 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2502 | 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 = 2522 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2527 | 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 = 2547 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2552 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -60007,14 +60064,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 = 2572 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2577 | 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 = 2647 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2652 | 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 = 2872 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2877 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -60025,14 +60082,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 = 2722 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2727 | 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 = 2797 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2802 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (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 = 2877 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2882 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -60043,12 +60100,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 = 2572 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2577 | 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 = 2647 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2652 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -60059,12 +60116,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 = 2722 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2727 | 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 = 2797 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2802 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -60072,12 +60129,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 = 2882 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 2887 | 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 = 2957 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 2962 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -60085,74 +60142,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 = 3032 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3037 | 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 = 3107 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3112 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3194 | SPEC_RULE_OP1; - } else if (op1_info == MAY_BE_DOUBLE) { spec = 3199 | SPEC_RULE_OP1; - } else if ((op->op1_type == IS_CONST) ? !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1)) : (!(op1_info & ((MAY_BE_ANY|MAY_BE_UNDEF)-(MAY_BE_NULL|MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_LONG|MAY_BE_DOUBLE))))) { + } else if (op1_info == MAY_BE_DOUBLE) { spec = 3204 | 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 = 3209 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3182 | SPEC_RULE_RETVAL; + spec = 3187 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3184 | SPEC_RULE_RETVAL; + spec = 3189 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3186 | SPEC_RULE_RETVAL; + spec = 3191 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3188 | SPEC_RULE_RETVAL; + spec = 3193 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3190; + spec = 3195; } else if (op1_info == MAY_BE_LONG) { - spec = 3191; + spec = 3196; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3192; + spec = 3197; } else if (op1_info == MAY_BE_LONG) { - spec = 3193; + spec = 3198; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2346; + spec = 2351; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2345; + spec = 2350; } break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3244; + spec = 3249; } break; case ZEND_SEND_VAR_EX: if (op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3239 | SPEC_RULE_OP1; + spec = 3244 | SPEC_RULE_OP1; } break; case ZEND_FE_FETCH_R: if (op->op2_type == IS_CV && (op1_info & (MAY_BE_UNDEF|MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 3246 | SPEC_RULE_RETVAL; + spec = 3251 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -60160,17 +60217,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 = 3209 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3214 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_SEND_VAL_EX: if (op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3245; + spec = 3250; } break; case ZEND_SEND_VAR: if ((op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3234 | SPEC_RULE_OP1; + spec = 3239 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 7a1fa9c98dd14..2b27b4e057874 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -1299,498 +1299,502 @@ _(2331, ZEND_CASE_STRICT_SPEC_VAR_TMP) \ _(2332, ZEND_CASE_STRICT_SPEC_VAR_VAR) \ _(2334, ZEND_CASE_STRICT_SPEC_VAR_CV) \ - _(2345, ZEND_RECV_NOTYPE_SPEC) \ - _(2346, ZEND_JMP_FORWARD_SPEC) \ - _(2352, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2353, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2354, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2356, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2345, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \ + _(2346, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2347, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2349, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \ + _(2350, ZEND_RECV_NOTYPE_SPEC) \ + _(2351, ZEND_JMP_FORWARD_SPEC) \ _(2357, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2358, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2359, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2361, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2367, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2368, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2369, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2371, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2377, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2378, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2379, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2381, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2362, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2363, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2364, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2366, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2372, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2373, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2374, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2376, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2382, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ _(2383, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2384, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2386, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2392, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2393, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2394, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2396, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2402, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2403, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2404, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2406, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2387, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2388, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2389, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2391, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2397, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2398, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2399, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2401, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2407, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2408, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2409, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2411, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2417, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2418, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2419, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2421, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2423, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2424, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2426, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2427, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2428, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2429, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2431, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2412, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2413, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2414, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2416, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2422, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2423, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2424, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2426, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2428, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2429, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2431, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ _(2432, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2433, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2434, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2436, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2442, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2443, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2444, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2446, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2448, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2449, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2451, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2452, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2453, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2454, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2456, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2437, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2438, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2439, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2441, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2447, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2448, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2449, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2451, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2453, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2454, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2456, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ _(2457, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ _(2458, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2459, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2461, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2467, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2468, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2469, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2471, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2473, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2474, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2476, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2477, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2478, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2479, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2481, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2462, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2463, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2464, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2466, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2472, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2473, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2474, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2476, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2478, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2479, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2481, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ _(2482, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2483, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2484, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2486, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2492, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2493, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2494, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2496, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2502, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2503, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2504, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2506, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2487, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2488, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2489, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2491, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2497, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2498, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2499, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2501, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2507, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ _(2508, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2509, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2511, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2517, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2518, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2519, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2521, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2527, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2528, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2529, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2531, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2512, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2513, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2514, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2516, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2522, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2523, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2524, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2526, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ _(2532, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ _(2533, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2534, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2536, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2542, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2543, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2544, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2546, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2552, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2553, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2554, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2556, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2537, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2538, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2539, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2541, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2547, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2548, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2549, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2551, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ _(2557, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ _(2558, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2559, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ _(2561, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2567, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2568, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2569, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2571, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2587, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2588, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2589, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2590, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2591, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2592, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2593, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2594, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2595, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2599, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2600, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2601, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2602, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2603, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2604, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2605, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2606, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2607, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2608, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2609, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2610, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2614, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2615, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2616, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2632, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2633, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2634, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2635, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2636, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2637, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2638, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2639, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2640, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2644, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2645, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2646, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2662, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2663, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2664, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2665, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2666, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2667, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2668, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2669, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2670, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2674, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2675, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2676, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2677, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2678, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2679, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2680, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2681, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2682, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2683, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2684, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2685, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2689, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2690, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2691, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2707, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2708, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2709, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2710, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2711, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2712, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2713, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2714, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2715, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2719, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2720, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2721, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2737, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2738, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2739, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2740, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2741, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2742, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2743, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2744, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2745, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2749, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2750, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2751, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2752, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2753, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2754, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2755, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2756, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2757, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2758, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2759, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2760, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2764, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2765, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2766, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2782, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2783, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2784, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2785, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2786, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2787, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2788, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2789, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2790, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2794, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2795, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2796, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2812, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2813, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2814, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2815, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2816, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2817, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2818, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2819, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2820, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2824, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2825, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2826, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2827, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2828, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2829, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2830, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2831, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2832, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2833, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2834, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2835, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2839, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2840, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2841, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2857, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2858, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2859, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2860, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2861, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2862, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2863, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2864, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2865, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2869, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2870, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2871, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2872, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(2876, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(2877, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(2881, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(2885, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(2886, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2887, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2888, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(2889, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2890, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2894, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(2895, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2896, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2897, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(2898, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2899, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2900, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2901, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2902, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2903, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2904, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2905, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2909, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2910, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2911, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2912, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(2913, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2914, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2915, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2916, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2917, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2918, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2919, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2920, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2924, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2925, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2926, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2942, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(2943, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2944, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2945, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2946, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2947, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2948, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2949, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2950, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2954, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2955, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2956, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2960, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2961, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2962, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2963, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2964, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2965, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2969, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2970, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(2971, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(2972, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2973, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2974, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2975, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2976, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2977, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2978, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2979, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2980, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2984, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2985, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2986, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2987, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2988, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2989, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2990, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2991, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2992, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2993, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2994, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2995, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2999, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3000, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3001, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3017, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3018, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3019, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3020, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3021, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3022, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3023, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3024, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3025, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3029, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3030, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3031, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3035, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3036, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3037, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3038, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3039, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3040, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3044, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3045, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3046, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3047, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3048, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3049, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3050, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3051, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3052, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3053, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3054, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3055, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3059, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3060, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3061, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3062, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3063, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3064, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3065, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3066, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3067, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3068, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3069, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3070, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3074, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3075, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3076, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3092, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3093, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3094, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3095, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3096, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3097, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3098, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3099, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3100, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3104, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3105, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3106, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3110, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3111, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3112, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3113, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3114, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3115, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3119, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3120, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3121, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3122, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3123, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3124, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3125, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3126, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3127, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3128, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3129, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3130, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3134, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3135, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3136, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3137, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3138, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3139, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3140, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3141, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3142, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3143, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3144, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3145, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3149, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3150, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3151, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3167, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3168, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3169, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3170, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3171, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3172, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3173, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3174, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3175, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3179, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3180, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3181, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3182, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3183, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3184, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3185, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3186, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3187, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3188, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3189, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3190, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3191, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3192, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3193, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3194, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ - _(3195, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3196, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3198, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3199, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(3200, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3201, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3203, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3204, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(3205, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3206, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3208, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3210, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3211, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3213, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3214, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3215, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3216, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3218, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(2562, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2563, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2564, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2566, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2572, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2573, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2574, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2576, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2592, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2593, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2594, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2595, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2596, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2597, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2598, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2599, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2600, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2604, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2605, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2606, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2607, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2608, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2609, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2610, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2611, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2612, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2613, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2614, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2615, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2619, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2620, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2621, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2637, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2638, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2639, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2640, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2641, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2642, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2643, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2644, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2645, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2649, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2650, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2651, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2667, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2668, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2669, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2670, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2671, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2672, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2673, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2674, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2675, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2679, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2680, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2681, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2682, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2683, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2684, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2685, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2686, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2687, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2688, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2689, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2690, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2694, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2695, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2696, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2712, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2713, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2714, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2715, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2716, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2717, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2718, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2719, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2720, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2724, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2725, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2726, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2742, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2743, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2744, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2745, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2746, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2747, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2748, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2749, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2750, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2754, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2755, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2756, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2757, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2758, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2759, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2760, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2761, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2762, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2763, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2764, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2765, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2769, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2770, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2771, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2787, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2788, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2789, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2790, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2791, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2792, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2793, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2794, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2795, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2799, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2800, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2801, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2817, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2818, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2819, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2820, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2821, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2822, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2823, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2824, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2825, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2829, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2830, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2831, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2832, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2833, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2834, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2835, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2836, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2837, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2838, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2839, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2840, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2844, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2845, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2846, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2862, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2863, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2864, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2865, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2866, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2867, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2868, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2869, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2870, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2874, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2875, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2876, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2877, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(2881, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(2882, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(2886, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(2890, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(2891, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2892, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2893, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(2894, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2895, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2899, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(2900, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2901, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2902, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(2903, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2904, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2905, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2906, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2907, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2908, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2909, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2910, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2914, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2915, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2916, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2917, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(2918, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2919, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2920, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2921, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2922, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2923, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2924, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2925, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2929, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2930, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2931, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2947, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(2948, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2949, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2950, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2951, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2952, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2953, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2954, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2955, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2959, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2960, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2961, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2965, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2966, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2967, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2968, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2969, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2970, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2974, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2975, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2976, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2977, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2978, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2979, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2980, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2981, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2982, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2983, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2984, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2985, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2989, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2990, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2991, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2992, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2993, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2994, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2995, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2996, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2997, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2998, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2999, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3000, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3004, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3005, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3006, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3022, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3023, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3024, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3025, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3026, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3027, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3028, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3029, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3030, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3034, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3035, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3036, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3040, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3041, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3042, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3043, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3044, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3045, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3049, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3050, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3051, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3052, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3053, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3054, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3055, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3056, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3057, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3058, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3059, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3060, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3064, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3065, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3066, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3067, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3068, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3069, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3070, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3071, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3072, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3073, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3074, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3075, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3079, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3080, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3081, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3097, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3098, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3099, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3100, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3101, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3102, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3103, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3104, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3105, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3109, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3110, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3111, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3115, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3116, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3117, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3118, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3119, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3120, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3124, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3125, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3126, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3127, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3128, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3129, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3130, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3131, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3132, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3133, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3134, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3135, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3139, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3140, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3141, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3142, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3143, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3144, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3145, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3146, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3147, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3148, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3149, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3150, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3154, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3155, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3156, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3172, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3173, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3174, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3175, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3176, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3177, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3178, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3179, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3180, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3184, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3185, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3186, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3187, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3188, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3189, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3190, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3191, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3192, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3193, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3194, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3195, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3196, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3197, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3198, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3199, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3200, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3201, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3203, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3204, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3205, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3206, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3208, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3209, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3210, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3211, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3213, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3215, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3216, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3218, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ _(3219, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ _(3220, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ _(3221, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ _(3223, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3229, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(3230, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3231, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3233, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3236, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3238, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3241, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \ - _(3243, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \ - _(3244, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3245, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3246, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3247, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3247+1, ZEND_NULL) + _(3224, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3225, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3226, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3228, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3234, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3235, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3236, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3238, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3241, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3243, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3246, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \ + _(3248, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \ + _(3249, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3250, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3251, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3252, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3252+1, ZEND_NULL) diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index 08b09d61aae3e..e51e476be30d4 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[197] = { +static const char *zend_vm_opcodes_names[198] = { "ZEND_NOP", "ZEND_ADD", "ZEND_SUB", @@ -220,9 +220,10 @@ static const char *zend_vm_opcodes_names[197] = { "ZEND_ARRAY_KEY_EXISTS", "ZEND_MATCH", "ZEND_CASE_STRICT", + "ZEND_MATCH_ERROR", }; -static uint32_t zend_vm_opcodes_flags[197] = { +static uint32_t zend_vm_opcodes_flags[198] = { 0x00000000, 0x00000b0b, 0x00000b0b, @@ -420,6 +421,7 @@ static uint32_t zend_vm_opcodes_flags[197] = { 0x00000707, 0x0300030b, 0x00000301, + 0x0000010b, }; 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 cad2a79863482..b196404060311 100644 --- a/Zend/zend_vm_opcodes.h +++ b/Zend/zend_vm_opcodes.h @@ -273,7 +273,8 @@ END_EXTERN_C() #define ZEND_ARRAY_KEY_EXISTS 194 #define ZEND_MATCH 195 #define ZEND_CASE_STRICT 196 +#define ZEND_MATCH_ERROR 197 -#define ZEND_VM_LAST_OPCODE 196 +#define ZEND_VM_LAST_OPCODE 197 #endif diff --git a/ext/opcache/Optimizer/dce.c b/ext/opcache/Optimizer/dce.c index 2df9d08768e73..9f533ea167392 100644 --- a/ext/opcache/Optimizer/dce.c +++ b/ext/opcache/Optimizer/dce.c @@ -147,6 +147,7 @@ static inline zend_bool may_have_side_effects( case ZEND_ECHO: case ZEND_INCLUDE_OR_EVAL: case ZEND_THROW: + case ZEND_MATCH_ERROR: case ZEND_EXT_STMT: case ZEND_EXT_FCALL_BEGIN: case ZEND_EXT_FCALL_END: diff --git a/ext/opcache/Optimizer/pass1.c b/ext/opcache/Optimizer/pass1.c index 84e23f118ff32..fee0e1eac36f6 100644 --- a/ext/opcache/Optimizer/pass1.c +++ b/ext/opcache/Optimizer/pass1.c @@ -664,6 +664,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) case ZEND_GENERATOR_RETURN: case ZEND_EXIT: case ZEND_THROW: + case ZEND_MATCH_ERROR: case ZEND_CATCH: case ZEND_FAST_CALL: case ZEND_FAST_RET: diff --git a/ext/opcache/Optimizer/zend_cfg.c b/ext/opcache/Optimizer/zend_cfg.c index 43b548acbb470..a80b416bb8e07 100644 --- a/ext/opcache/Optimizer/zend_cfg.c +++ b/ext/opcache/Optimizer/zend_cfg.c @@ -300,6 +300,7 @@ int zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, uint32_t b case ZEND_RETURN_BY_REF: case ZEND_GENERATOR_RETURN: case ZEND_EXIT: + case ZEND_MATCH_ERROR: if (i + 1 < op_array->last) { BB_START(i + 1); } @@ -512,6 +513,7 @@ int zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, uint32_t b case ZEND_GENERATOR_RETURN: case ZEND_EXIT: case ZEND_THROW: + case ZEND_MATCH_ERROR: break; case ZEND_JMP: block->successors_count = 1; diff --git a/ext/opcache/jit/zend_jit.c b/ext/opcache/jit/zend_jit.c index 34bc928407cbb..d0c1178d695f2 100644 --- a/ext/opcache/jit/zend_jit.c +++ b/ext/opcache/jit/zend_jit.c @@ -2923,6 +2923,7 @@ static int zend_jit(const zend_op_array *op_array, zend_ssa *ssa, const zend_op case ZEND_RETURN_BY_REF: case ZEND_RETURN: case ZEND_EXIT: + case ZEND_MATCH_ERROR: /* switch through trampoline */ case ZEND_YIELD: case ZEND_YIELD_FROM: diff --git a/ext/opcache/jit/zend_jit_trace.c b/ext/opcache/jit/zend_jit_trace.c index 341a90b6fbfd2..278b3e61515fd 100644 --- a/ext/opcache/jit/zend_jit_trace.c +++ b/ext/opcache/jit/zend_jit_trace.c @@ -297,6 +297,7 @@ static int zend_jit_trace_may_exit(const zend_op_array *op_array, const zend_op case ZEND_YIELD: case ZEND_YIELD_FROM: case ZEND_INCLUDE_OR_EVAL: + case ZEND_MATCH_ERROR: /* unsupported */ return 1; case ZEND_DO_FCALL: From eb29cbea3ea8afaa2d539d493e350ff0de198021 Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Wed, 8 Jul 2020 19:36:05 +0200 Subject: [PATCH 05/14] Fix falling through match on undefined variable --- Zend/tests/match/042.phpt | 12 ++++++++++-- Zend/zend_vm_def.h | 7 +++++-- Zend/zend_vm_execute.h | 14 ++++++++++---- 3 files changed, 25 insertions(+), 8 deletions(-) diff --git a/Zend/tests/match/042.phpt b/Zend/tests/match/042.phpt index 0220cf40440f9..a9931c30d54b3 100644 --- a/Zend/tests/match/042.phpt +++ b/Zend/tests/match/042.phpt @@ -4,11 +4,19 @@ Match expression with undefined variable as expression null, + null => 'null', default => 'default', }); +var_dump(match ($undefinedVariable) { + 1, 2, 3, 4, 5 => 'foo', + default => 'bar', +}); + ?> --EXPECTF-- Warning: Undefined variable $undefinedVariable in %s.php on line 3 -NULL +string(4) "null" + +Warning: Undefined variable $undefinedVariable in /Users/ilijatovilo/Developer/php-src/Zend/tests/match/042.php on line 8 +string(3) "bar" diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 39b40f2f9e432..cc59696f50eef 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -8428,8 +8428,11 @@ ZEND_VM_C_LABEL(match_try_again): } else { if (UNEXPECTED((OP1_TYPE & IS_CV) && Z_TYPE_P(op) == IS_UNDEF)) { SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + op = ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + ZEND_VM_C_GOTO(match_try_again); } ZEND_VM_C_GOTO(default_branch); diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index a63df8f4c5a6b..310cdec005313 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -6516,8 +6516,11 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_SPEC_CONST_ } else { if (UNEXPECTED((IS_CONST & IS_CV) && Z_TYPE_P(op) == IS_UNDEF)) { SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + op = ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + goto match_try_again; } goto default_branch; @@ -11427,8 +11430,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_SPEC_TMPVARCV_CONST_HAND } else { if (UNEXPECTED(((IS_TMP_VAR|IS_VAR|IS_CV) & IS_CV) && Z_TYPE_P(op) == IS_UNDEF)) { SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + op = ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + goto match_try_again; } goto default_branch; From f96b1ceab891c341c3b384f8cfa34a4751d4d139 Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Wed, 8 Jul 2020 19:39:39 +0200 Subject: [PATCH 06/14] Remove value in UnhandledMatchError message --- Zend/tests/match/006.phpt | 2 +- Zend/tests/match/007.phpt | 2 +- Zend/tests/match/037.phpt | 6 ++--- Zend/tests/match/043.phpt | 39 --------------------------------- Zend/zend.c | 46 --------------------------------------- Zend/zend.h | 1 - Zend/zend_vm_def.h | 12 ++-------- Zend/zend_vm_execute.h | 24 ++++---------------- 8 files changed, 11 insertions(+), 121 deletions(-) delete mode 100644 Zend/tests/match/043.phpt diff --git a/Zend/tests/match/006.phpt b/Zend/tests/match/006.phpt index 9ab998eee3b23..fec28f82da631 100644 --- a/Zend/tests/match/006.phpt +++ b/Zend/tests/match/006.phpt @@ -7,7 +7,7 @@ $x = match (true) {}; ?> --EXPECTF-- -Fatal error: Uncaught UnhandledMatchError: Unhandled match value true in %s +Fatal error: Uncaught UnhandledMatchError: Unhandled match value of type bool in %s Stack trace: #0 {main} thrown in %s on line %d diff --git a/Zend/tests/match/007.phpt b/Zend/tests/match/007.phpt index 3fdc5dca2f5d2..7b442a66a03e5 100644 --- a/Zend/tests/match/007.phpt +++ b/Zend/tests/match/007.phpt @@ -19,7 +19,7 @@ echo get_value(3) . "\n"; 1 2 -Fatal error: Uncaught UnhandledMatchError: Unhandled match value 3 in %s +Fatal error: Uncaught UnhandledMatchError: Unhandled match value of type int in %s Stack trace: #0 %s: get_value(3) #1 {main} diff --git a/Zend/tests/match/037.phpt b/Zend/tests/match/037.phpt index a29d52025dd8e..e114696f5fb9b 100644 --- a/Zend/tests/match/037.phpt +++ b/Zend/tests/match/037.phpt @@ -52,13 +52,13 @@ var_dump(match(3) { }); --EXPECTF-- -string(%d) "UnhandledMatchError: Unhandled match value true in %s037.php:5 +string(%d) "UnhandledMatchError: Unhandled match value of type bool in %s037.php:5 Stack trace: #0 {main}" -string(%d) "UnhandledMatchError: Unhandled match value 6 in %s037.php:13 +string(%d) "UnhandledMatchError: Unhandled match value of type int in %s037.php:13 Stack trace: #0 {main}" -string(%d) "UnhandledMatchError: Unhandled match value "3" in %s037.php:21 +string(%d) "UnhandledMatchError: Unhandled match value of type string in %s037.php:21 Stack trace: #0 {main}" string(3) "foo" diff --git a/Zend/tests/match/043.phpt b/Zend/tests/match/043.phpt deleted file mode 100644 index 84e5a38553a31..0000000000000 --- a/Zend/tests/match/043.phpt +++ /dev/null @@ -1,39 +0,0 @@ ---TEST-- -Match expression error message ---FILE-- -getMessage() . "\n"; - } -} - -test($a); -test([]); -test((object) []); -test(fopen('php://stdout', 'w')); -test(null); -test(false); -test(true); -test(42); -test(pi()); -test("Foo bar"); -test("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas pretium ante tellus, a molestie sapien commodo sed. Nulla pellentesque nulla eget tellus fringilla tristique."); - -?> ---EXPECTF-- -Warning: Undefined variable $a in %s.php on line 11 -Unhandled match value null -Unhandled match value of type array -Unhandled match value of type stdClass -Unhandled match value of type resource -Unhandled match value null -Unhandled match value false -Unhandled match value true -Unhandled match value 42 -Unhandled match value 3.1415926535898 -Unhandled match value "Foo bar" -Unhandled match value "Lorem ipsum dolor si..." diff --git a/Zend/zend.c b/Zend/zend.c index 7ff32c5a1cd01..673048c0a56b3 100644 --- a/Zend/zend.c +++ b/Zend/zend.c @@ -503,52 +503,6 @@ ZEND_API void zend_print_zval_r(zval *expr, int indent) /* {{{ */ } /* }}} */ -ZEND_API zend_string *zend_zval_to_readable_string(zval *expr) -{ -try_again: - switch (Z_TYPE_P(expr)) { - case IS_UNDEF: - case IS_ARRAY: - case IS_OBJECT: - case IS_RESOURCE: - return NULL; - case IS_NULL: - return zend_string_init("null", strlen("null"), 0); - case IS_FALSE: - return zend_string_init("false", strlen("false"), 0); - case IS_TRUE: - return zend_string_init("true", strlen("true"), 0); - case IS_LONG: - return zend_long_to_str(Z_LVAL_P(expr)); - case IS_DOUBLE: - return zend_strpprintf_unchecked(0, "%.*H", (int) EG(precision), Z_DVAL_P(expr)); - case IS_STRING: { - zend_string *str = Z_STR_P(expr); - size_t str_len = ZSTR_LEN(str); - smart_str readable_str = {0}; - smart_str_appendc(&readable_str, '"'); - if (str_len <= READABLE_ZVAL_MAX_STR_LENGTH) { - smart_str_appends(&readable_str, ZSTR_VAL(str)); - } else { - // FIXME: Doesn't handle multi byte strings - zend_string *truncated_str = zend_string_init_fast(ZSTR_VAL(str), READABLE_ZVAL_MAX_STR_LENGTH); - // FIXME: Doesn't handle escaping of special chars (namely " and \) - smart_str_appends(&readable_str, ZSTR_VAL(truncated_str)); - zend_string_release_ex(truncated_str, 0); - smart_str_appends(&readable_str, "..."); - } - smart_str_appendc(&readable_str, '"'); - smart_str_0(&readable_str); - return readable_str.s; - } - case IS_REFERENCE: - expr = Z_REFVAL_P(expr); - goto try_again; - EMPTY_SWITCH_DEFAULT_CASE() - } - return NULL; -} - static FILE *zend_fopen_wrapper(const char *filename, zend_string **opened_path) /* {{{ */ { if (opened_path) { diff --git a/Zend/zend.h b/Zend/zend.h index bbbeb79aea202..4fe89fcacc809 100644 --- a/Zend/zend.h +++ b/Zend/zend.h @@ -251,7 +251,6 @@ ZEND_API size_t zend_print_zval(zval *expr, int indent); ZEND_API void zend_print_zval_r(zval *expr, int indent); ZEND_API zend_string *zend_print_zval_r_to_str(zval *expr, int indent); ZEND_API void zend_print_flat_zval_r(zval *expr); -ZEND_API zend_string *zend_zval_to_readable_string(zval *expr); #define zend_print_variable(var) \ zend_print_zval((var), 0) diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index cc59696f50eef..b4067f7645b76 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -8453,18 +8453,10 @@ ZEND_VM_COLD_CONST_HANDLER(197, ZEND_MATCH_ERROR, CONST|TMPVARCV, UNUSED) { USE_OPLINE zval *op; - zend_string *zval_str; + SAVE_OPLINE(); op = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R); - zval_str = zend_zval_to_readable_string(op); - - if (zval_str != NULL) { - zend_throw_exception_ex(zend_ce_unhandled_match_error, 0, "Unhandled match value %s", ZSTR_VAL(zval_str)); - zend_string_release_ex(zval_str, 0); - } else { - zend_throw_exception_ex(zend_ce_unhandled_match_error, 0, "Unhandled match value of type %s", zend_zval_type_name(op)); - } - + zend_throw_exception_ex(zend_ce_unhandled_match_error, 0, "Unhandled match value of type %s", zend_zval_type_name(op)); HANDLE_EXCEPTION(); } diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 310cdec005313..14a955f17dd13 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -9282,18 +9282,10 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_ERROR_SPEC_ { USE_OPLINE zval *op; - zend_string *zval_str; + SAVE_OPLINE(); op = RT_CONSTANT(opline, opline->op1); - zval_str = zend_zval_to_readable_string(op); - - if (zval_str != NULL) { - zend_throw_exception_ex(zend_ce_unhandled_match_error, 0, "Unhandled match value %s", ZSTR_VAL(zval_str)); - zend_string_release_ex(zval_str, 0); - } else { - zend_throw_exception_ex(zend_ce_unhandled_match_error, 0, "Unhandled match value of type %s", zend_zval_type_name(op)); - } - + zend_throw_exception_ex(zend_ce_unhandled_match_error, 0, "Unhandled match value of type %s", zend_zval_type_name(op)); HANDLE_EXCEPTION(); } @@ -12771,18 +12763,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUS { USE_OPLINE zval *op; - zend_string *zval_str; + SAVE_OPLINE(); op = EX_VAR(opline->op1.var); - zval_str = zend_zval_to_readable_string(op); - - if (zval_str != NULL) { - zend_throw_exception_ex(zend_ce_unhandled_match_error, 0, "Unhandled match value %s", ZSTR_VAL(zval_str)); - zend_string_release_ex(zval_str, 0); - } else { - zend_throw_exception_ex(zend_ce_unhandled_match_error, 0, "Unhandled match value of type %s", zend_zval_type_name(op)); - } - + zend_throw_exception_ex(zend_ce_unhandled_match_error, 0, "Unhandled match value of type %s", zend_zval_type_name(op)); HANDLE_EXCEPTION(); } From 98bdbafb4ff9c1bc635be6dd5e1d00aab079f3fe Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Wed, 8 Jul 2020 19:42:45 +0200 Subject: [PATCH 07/14] Fix match opcache test --- Zend/tests/match/042.phpt | 2 +- ext/opcache/tests/match/001.phpt | 8 ++------ 2 files changed, 3 insertions(+), 7 deletions(-) diff --git a/Zend/tests/match/042.phpt b/Zend/tests/match/042.phpt index a9931c30d54b3..6ea30dd3764ce 100644 --- a/Zend/tests/match/042.phpt +++ b/Zend/tests/match/042.phpt @@ -18,5 +18,5 @@ var_dump(match ($undefinedVariable) { Warning: Undefined variable $undefinedVariable in %s.php on line 3 string(4) "null" -Warning: Undefined variable $undefinedVariable in /Users/ilijatovilo/Developer/php-src/Zend/tests/match/042.php on line 8 +Warning: Undefined variable $undefinedVariable in %s.php on line 8 string(3) "bar" diff --git a/ext/opcache/tests/match/001.phpt b/ext/opcache/tests/match/001.phpt index 172808fe4117d..0f6c4f07075c8 100644 --- a/ext/opcache/tests/match/001.phpt +++ b/ext/opcache/tests/match/001.phpt @@ -48,7 +48,7 @@ LIVE RANGES: 1: 0005 - 0013 (loop) test: - ; (lines=11, args=1, vars=1, tmps=1) + ; (lines=9, args=1, vars=1, tmps=0) ; (after optimizer) ; %s 0000 CV0($char) = RECV 1 @@ -59,11 +59,7 @@ test: 0005 RETURN string("e, f") 0006 RETURN string("g") 0007 RETURN string("h, i") -0008 V1 = NEW 0 string("UnhandledMatchError") -0009 DO_FCALL -0010 THROW V1 -LIVE RANGES: - 1: 0009 - 0010 (new) +0008 MATCH_ERROR CV0($char) string(1) "a" string(4) "b, c" string(4) "b, c" From 21f356df123182a0412d5d0d2df8809cfdc2ab1b Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Wed, 8 Jul 2020 19:49:44 +0200 Subject: [PATCH 08/14] Fix BB successors of ZEND_MATCH --- ext/opcache/Optimizer/block_pass.c | 6 +++--- ext/opcache/Optimizer/zend_cfg.c | 6 ++++-- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/ext/opcache/Optimizer/block_pass.c b/ext/opcache/Optimizer/block_pass.c index 6cd121a471151..aee3931f0520d 100644 --- a/ext/opcache/Optimizer/block_pass.c +++ b/ext/opcache/Optimizer/block_pass.c @@ -117,7 +117,7 @@ static int get_const_switch_target(zend_cfg *cfg, zend_op_array *op_array, zend_ } if (opline->opcode == ZEND_MATCH && Z_TYPE_P(val) != IS_LONG && Z_TYPE_P(val) != IS_STRING) { /* always jump to the default arm */ - return block->successors[block->successors_count - 2]; + return block->successors[block->successors_count - 1]; } if (Z_TYPE_P(val) == IS_LONG) { zv = zend_hash_index_find(jumptable, Z_LVAL_P(val)); @@ -127,7 +127,7 @@ static int get_const_switch_target(zend_cfg *cfg, zend_op_array *op_array, zend_ } if (!zv) { /* default */ - return block->successors[block->successors_count - 2]; + return block->successors[block->successors_count - (opline->opcode == ZEND_MATCH ? 1 : 2)]; } return cfg->map[ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, Z_LVAL_P(zv))]; } @@ -1057,7 +1057,7 @@ static void assemble_code_blocks(zend_cfg *cfg, zend_op_array *op_array, zend_op HashTable *jumptable = Z_ARRVAL(ZEND_OP2_LITERAL(opline)); zval *zv; uint32_t s = 0; - ZEND_ASSERT(b->successors_count == 2 + zend_hash_num_elements(jumptable)); + ZEND_ASSERT(b->successors_count == (opline->opcode == ZEND_MATCH ? 1 : 2) + zend_hash_num_elements(jumptable)); ZEND_HASH_FOREACH_VAL(jumptable, zv) { Z_LVAL_P(zv) = ZEND_OPLINE_TO_OFFSET(opline, new_opcodes + blocks[b->successors[s++]].start); diff --git a/ext/opcache/Optimizer/zend_cfg.c b/ext/opcache/Optimizer/zend_cfg.c index a80b416bb8e07..d80edda3e1b0d 100644 --- a/ext/opcache/Optimizer/zend_cfg.c +++ b/ext/opcache/Optimizer/zend_cfg.c @@ -570,7 +570,7 @@ int zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, uint32_t b zval *zv; uint32_t s = 0; - block->successors_count = 2 + zend_hash_num_elements(jumptable); + block->successors_count = (opline->opcode == ZEND_MATCH ? 1 : 2) + zend_hash_num_elements(jumptable); block->successors = zend_arena_calloc(arena, block->successors_count, sizeof(int)); ZEND_HASH_FOREACH_VAL(jumptable, zv) { @@ -578,7 +578,9 @@ int zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, uint32_t b } ZEND_HASH_FOREACH_END(); block->successors[s++] = block_map[ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value)]; - block->successors[s++] = j + 1; + if (opline->opcode != ZEND_MATCH) { + block->successors[s++] = j + 1; + } break; } default: From 2c84da274d03da5d9527406e0cbba630b16cffb4 Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Thu, 9 Jul 2020 18:58:16 +0200 Subject: [PATCH 09/14] Remove unused constant --- Zend/zend.c | 1 - 1 file changed, 1 deletion(-) diff --git a/Zend/zend.c b/Zend/zend.c index 673048c0a56b3..2765f8c3ead22 100644 --- a/Zend/zend.c +++ b/Zend/zend.c @@ -66,7 +66,6 @@ static char *zend_version_info; static uint32_t zend_version_info_length; #define ZEND_CORE_VERSION_INFO "Zend Engine v" ZEND_VERSION ", Copyright (c) Zend Technologies\n" #define PRINT_ZVAL_INDENT 4 -#define READABLE_ZVAL_MAX_STR_LENGTH 20 /* true multithread-shared globals */ ZEND_API zend_class_entry *zend_standard_class_def = NULL; From 11371644b998771ed670027bdce9ef9ac264f350 Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Thu, 9 Jul 2020 19:00:11 +0200 Subject: [PATCH 10/14] Revert unused change in should_use_jumptable for match --- Zend/zend_compile.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 1bcfda8f37c1f..ebddbad7583f0 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -5018,7 +5018,7 @@ static zend_uchar determine_switch_jumptable_type(zend_ast_list *cases) { return common_type; } -static zend_bool should_use_jumptable(uint32_t num_children, zend_uchar jumptable_type) { +static zend_bool should_use_jumptable(zend_ast_list *cases, zend_uchar jumptable_type) { if (CG(compiler_options) & ZEND_COMPILE_NO_JUMPTABLES) { return 0; } @@ -5026,10 +5026,10 @@ static zend_bool should_use_jumptable(uint32_t num_children, zend_uchar jumptabl /* Thresholds are chosen based on when the average switch time for equidistributed * input becomes smaller when using the jumptable optimization. */ if (jumptable_type == IS_LONG) { - return num_children >= 5; + return cases->children >= 5; } else { ZEND_ASSERT(jumptable_type == IS_STRING); - return num_children >= 2; + return cases->children >= 2; } } @@ -5055,7 +5055,7 @@ void zend_compile_switch(zend_ast *ast) /* {{{ */ case_node.u.op.var = get_temporary_variable(); jumptable_type = determine_switch_jumptable_type(cases); - if (jumptable_type != IS_UNDEF && should_use_jumptable(cases->children, jumptable_type)) { + if (jumptable_type != IS_UNDEF && should_use_jumptable(cases, jumptable_type)) { znode jumptable_op; ALLOC_HASHTABLE(jumptable); From c89fd6f7dbc70213ae9a6ee61706356918a1f226 Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Thu, 9 Jul 2020 19:01:06 +0200 Subject: [PATCH 11/14] Remove vim folding --- Zend/zend_compile.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index ebddbad7583f0..b2a33068f53e2 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -5211,7 +5211,7 @@ static zend_bool can_match_use_jumptable(zend_ast_list *arms) { return 1; } -void zend_compile_match(znode *result, zend_ast *ast) /* {{{ */ +void zend_compile_match(znode *result, zend_ast *ast) { zend_ast *expr_ast = ast->child[0]; zend_ast_list *arms = zend_ast_get_list(ast->child[1]); @@ -5387,7 +5387,6 @@ void zend_compile_match(znode *result, zend_ast *ast) /* {{{ */ } efree(jmp_end_opnums); } -/* }}} */ void zend_compile_try(zend_ast *ast) /* {{{ */ { From 909a003ee36df091175f5a88129e13832b14d1d8 Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Thu, 9 Jul 2020 19:02:22 +0200 Subject: [PATCH 12/14] Inline production match_arm_body --- Zend/zend_language_parser.y | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y index b9674010cb7be..aa3164b735d0a 100644 --- a/Zend/zend_language_parser.y +++ b/Zend/zend_language_parser.y @@ -262,7 +262,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %type inline_function union_type %type attributed_statement attributed_class_statement attributed_parameter %type attribute_decl attribute attributes -%type match match_arm_list non_empty_match_arm_list match_arm match_arm_cond_list match_arm_body +%type match match_arm_list non_empty_match_arm_list match_arm match_arm_cond_list %type returns_ref function fn is_reference is_variadic variable_modifiers %type method_modifiers non_empty_member_modifiers member_modifier optional_visibility_modifier @@ -642,9 +642,9 @@ non_empty_match_arm_list: ; match_arm: - match_arm_cond_list possible_comma T_DOUBLE_ARROW match_arm_body + match_arm_cond_list possible_comma T_DOUBLE_ARROW expr { $$ = zend_ast_create(ZEND_AST_MATCH_ARM, $1, $4); } - | T_DEFAULT possible_comma T_DOUBLE_ARROW match_arm_body + | T_DEFAULT possible_comma T_DOUBLE_ARROW expr { $$ = zend_ast_create(ZEND_AST_MATCH_ARM, NULL, $4); } ; @@ -653,10 +653,6 @@ match_arm_cond_list: | match_arm_cond_list ',' expr { $$ = zend_ast_list_add($1, $3); } ; -match_arm_body: - expr { $$ = $1; } -; - while_statement: statement { $$ = $1; } From c78173d42649f5ea9499be8ff7caee96d07869e9 Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Thu, 9 Jul 2020 19:06:20 +0200 Subject: [PATCH 13/14] ZEND_CASE_STRICT may never throw --- ext/opcache/Optimizer/zend_inference.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ext/opcache/Optimizer/zend_inference.c b/ext/opcache/Optimizer/zend_inference.c index a1ceb5fd456d0..00708ca11bcb3 100644 --- a/ext/opcache/Optimizer/zend_inference.c +++ b/ext/opcache/Optimizer/zend_inference.c @@ -4389,6 +4389,7 @@ int zend_may_throw_ex(const zend_op *opline, const zend_ssa_op *ssa_op, const ze case ZEND_FUNC_GET_ARGS: case ZEND_COPY_TMP: case ZEND_CHECK_FUNC_ARG: + case ZEND_CASE_STRICT: return 0; case ZEND_INIT_FCALL: /* can't throw, because call is resolved at compile time */ @@ -4460,7 +4461,6 @@ int zend_may_throw_ex(const zend_op *opline, const zend_ssa_op *ssa_op, const ze case ZEND_IS_SMALLER: case ZEND_IS_SMALLER_OR_EQUAL: case ZEND_CASE: - case ZEND_CASE_STRICT: case ZEND_SPACESHIP: if ((t1 & MAY_BE_ANY) == MAY_BE_NULL || (t2 & MAY_BE_ANY) == MAY_BE_NULL) { From ec09601c62878614800907f3d7307d8c68cf571e Mon Sep 17 00:00:00 2001 From: Ilija Tovilo Date: Thu, 9 Jul 2020 19:09:59 +0200 Subject: [PATCH 14/14] Fix taken successor for switch/match with mismatched type --- ext/opcache/Optimizer/dfa_pass.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ext/opcache/Optimizer/dfa_pass.c b/ext/opcache/Optimizer/dfa_pass.c index da2f445acfd4e..0b69323980c7c 100644 --- a/ext/opcache/Optimizer/dfa_pass.c +++ b/ext/opcache/Optimizer/dfa_pass.c @@ -910,7 +910,7 @@ static int zend_dfa_optimize_jmps(zend_op_array *op_array, zend_ssa *ssa) removed_ops++; MAKE_NOP(opline); opline->extended_value = 0; - take_successor_ex(ssa, block_num, block, block->successors[0]); + take_successor_ex(ssa, block_num, block, block->successors[block->successors_count - 1]); goto optimize_nop; } else { HashTable *jmptable = Z_ARRVAL_P(CT_CONSTANT_EX(op_array, opline->op2.constant));