diff options
Diffstat (limited to 'Zend')
40 files changed, 1594 insertions, 517 deletions
diff --git a/Zend/tests/nullsafe_operator/001.phpt b/Zend/tests/nullsafe_operator/001.phpt new file mode 100644 index 0000000000..22776006a7 --- /dev/null +++ b/Zend/tests/nullsafe_operator/001.phpt @@ -0,0 +1,106 @@ +--TEST-- +Test basic nullsafe method calls +--FILE-- +<?php + +class Foo { + function null() { + var_dump('Foo::null()'); + return null; + } + + function self() { + var_dump('Foo::self()'); + return $this; + } +} + +var_dump(null?->bar()); +var_dump(null?->bar(var_dump('Not executed'))); +var_dump(null?->bar()->baz()); +var_dump(null?->bar()->baz(var_dump('Not executed'))); +var_dump(null?->bar()->baz); +var_dump(null?->bar()::$baz); +var_dump(null?->bar()::baz()); + +$foo = new Foo(); +var_dump($foo->null()?->bar()); +var_dump($foo->null()?->bar(var_dump('Not executed'))); +var_dump($foo->null()?->bar()->baz()); +var_dump($foo->null()?->bar()->baz(var_dump('Not executed'))); +var_dump($foo->null()?->bar()->baz); +var_dump($foo->null()?->bar()::$baz); +var_dump($foo->null()?->bar()::baz()); + +$foo = new Foo(); +var_dump($foo?->self(var_dump('Executed'))->null()?->bar()); +var_dump($foo?->self(var_dump('Executed'))->null()?->bar(var_dump('Not executed'))); +var_dump($foo?->self(var_dump('Executed'))->null()?->bar()->baz()); +var_dump($foo?->self(var_dump('Executed'))->null()?->bar()->baz(var_dump('Not executed'))); +var_dump($foo?->self(var_dump('Executed'))->null()?->bar()->baz); +var_dump($foo?->self(var_dump('Executed'))->null()?->bar()::$baz); +var_dump($foo?->self(var_dump('Executed'))->null()?->bar()::baz()); + +var_dump($foo->self(null?->bar())->null()); +try { + var_dump($foo?->self()[null?->bar()]); +} catch (Throwable $e) { + var_dump($e->getMessage()); +} + +?> +--EXPECT-- +NULL +NULL +NULL +NULL +NULL +NULL +NULL +string(11) "Foo::null()" +NULL +string(11) "Foo::null()" +NULL +string(11) "Foo::null()" +NULL +string(11) "Foo::null()" +NULL +string(11) "Foo::null()" +NULL +string(11) "Foo::null()" +NULL +string(11) "Foo::null()" +NULL +string(8) "Executed" +string(11) "Foo::self()" +string(11) "Foo::null()" +NULL +string(8) "Executed" +string(11) "Foo::self()" +string(11) "Foo::null()" +NULL +string(8) "Executed" +string(11) "Foo::self()" +string(11) "Foo::null()" +NULL +string(8) "Executed" +string(11) "Foo::self()" +string(11) "Foo::null()" +NULL +string(8) "Executed" +string(11) "Foo::self()" +string(11) "Foo::null()" +NULL +string(8) "Executed" +string(11) "Foo::self()" +string(11) "Foo::null()" +NULL +string(8) "Executed" +string(11) "Foo::self()" +string(11) "Foo::null()" +NULL +string(11) "Foo::self()" +string(11) "Foo::null()" +NULL +string(11) "Foo::self()" +string(38) "Cannot use object of type Foo as array" diff --git a/Zend/tests/nullsafe_operator/002.phpt b/Zend/tests/nullsafe_operator/002.phpt new file mode 100644 index 0000000000..46c1bb623f --- /dev/null +++ b/Zend/tests/nullsafe_operator/002.phpt @@ -0,0 +1,42 @@ +--TEST-- +Test nullsafe strict type check +--FILE-- +<?php + +try { + false?->bar(); +} catch (Throwable $e) { + var_dump($e->getMessage()); +} + +try { + []?->bar(); +} catch (Throwable $e) { + var_dump($e->getMessage()); +} + +try { + (0)?->bar(); +} catch (Throwable $e) { + var_dump($e->getMessage()); +} + +try { + (0.0)?->bar(); +} catch (Throwable $e) { + var_dump($e->getMessage()); +} + +try { + ''?->bar(); +} catch (Throwable $e) { + var_dump($e->getMessage()); +} + +?> +--EXPECT-- +string(39) "Call to a member function bar() on bool" +string(40) "Call to a member function bar() on array" +string(38) "Call to a member function bar() on int" +string(40) "Call to a member function bar() on float" +string(41) "Call to a member function bar() on string" diff --git a/Zend/tests/nullsafe_operator/003.phpt b/Zend/tests/nullsafe_operator/003.phpt new file mode 100644 index 0000000000..b19c619eeb --- /dev/null +++ b/Zend/tests/nullsafe_operator/003.phpt @@ -0,0 +1,66 @@ +--TEST-- +Test basic nullsafe property fetching +--FILE-- +<?php + +class Foo { + public $bar = 'bar'; + + function qux() { + return 'qux'; + } +} + +$null = null; +$foo = new Foo(); + +var_dump(null?->bar); +var_dump(null?->baz); +var_dump(null?->qux()); +var_dump(null?->quux()); + +var_dump((new Foo)?->bar); +var_dump((new Foo)?->baz); +var_dump((new Foo)?->qux()); +try { + var_dump((new Foo)?->quux()); +} catch (Throwable $e) { + var_dump($e->getMessage()); +} + +var_dump("{$null?->foo}"); +var_dump("{$null?->bar}"); +var_dump("{$null?->qux()}"); +var_dump("{$null?->quux()}"); + +var_dump("{$foo?->bar}"); +var_dump("{$foo?->baz}"); +var_dump("{$foo?->qux()}"); +try { + var_dump("{$foo?->quux()}"); +} catch (Throwable $e) { + var_dump($e->getMessage()); +} + +?> +--EXPECTF-- +NULL +NULL +NULL +NULL +string(3) "bar" + +Warning: Undefined property: Foo::$baz in %s.php on line 20 +NULL +string(3) "qux" +string(36) "Call to undefined method Foo::quux()" +string(0) "" +string(0) "" +string(0) "" +string(0) "" +string(3) "bar" + +Warning: Undefined property: Foo::$baz in %s.php on line 34 +string(0) "" +string(3) "qux" +string(36) "Call to undefined method Foo::quux()" diff --git a/Zend/tests/nullsafe_operator/004.phpt b/Zend/tests/nullsafe_operator/004.phpt new file mode 100644 index 0000000000..0dc95d3f1a --- /dev/null +++ b/Zend/tests/nullsafe_operator/004.phpt @@ -0,0 +1,11 @@ +--TEST-- +Test nullsafe property assignment +--FILE-- +<?php + +$foo = null; +var_dump($foo?->bar = 'bar'); + +?> +--EXPECTF-- +Fatal error: Can't use nullsafe operator in write context in %s.php on line 4 diff --git a/Zend/tests/nullsafe_operator/005.phpt b/Zend/tests/nullsafe_operator/005.phpt new file mode 100644 index 0000000000..e691401599 --- /dev/null +++ b/Zend/tests/nullsafe_operator/005.phpt @@ -0,0 +1,11 @@ +--TEST-- +Test nullsafe property assignment op +--FILE-- +<?php + +$foo = null; +$foo?->bar += 1; + +?> +--EXPECTF-- +Fatal error: Can't use nullsafe operator in write context in %s.php on line 4 diff --git a/Zend/tests/nullsafe_operator/006.phpt b/Zend/tests/nullsafe_operator/006.phpt new file mode 100644 index 0000000000..2cbecd2dda --- /dev/null +++ b/Zend/tests/nullsafe_operator/006.phpt @@ -0,0 +1,11 @@ +--TEST-- +Test nullsafe property post increment +--FILE-- +<?php + +$foo = null; +++$foo?->bar; + +?> +--EXPECTF-- +Fatal error: Can't use nullsafe operator in write context in %s.php on line 4 diff --git a/Zend/tests/nullsafe_operator/007.phpt b/Zend/tests/nullsafe_operator/007.phpt new file mode 100644 index 0000000000..a04af8ea83 --- /dev/null +++ b/Zend/tests/nullsafe_operator/007.phpt @@ -0,0 +1,11 @@ +--TEST-- +Test nullsafe property pre increment +--FILE-- +<?php + +$foo = null; +var_dump($foo?->bar++); + +?> +--EXPECTF-- +Fatal error: Can't use nullsafe operator in write context in %s.php on line 4 diff --git a/Zend/tests/nullsafe_operator/008.phpt b/Zend/tests/nullsafe_operator/008.phpt new file mode 100644 index 0000000000..360d137b86 --- /dev/null +++ b/Zend/tests/nullsafe_operator/008.phpt @@ -0,0 +1,11 @@ +--TEST-- +Test nullsafe property coalesce assignment +--FILE-- +<?php + +$foo = null; +var_dump($foo?->bar ??= 'bar'); + +?> +--EXPECTF-- +Fatal error: Can't use nullsafe operator in write context in %s.php on line 4 diff --git a/Zend/tests/nullsafe_operator/009.phpt b/Zend/tests/nullsafe_operator/009.phpt new file mode 100644 index 0000000000..95df9dacc8 --- /dev/null +++ b/Zend/tests/nullsafe_operator/009.phpt @@ -0,0 +1,11 @@ +--TEST-- +Test fetch nullsafe property by ref +--FILE-- +<?php + +$foo = null; +$ref = &$foo?->bar + +?> +--EXPECTF-- +Fatal error: Cannot take reference of a nullsafe chain in %s.php on line 4 diff --git a/Zend/tests/nullsafe_operator/010.phpt b/Zend/tests/nullsafe_operator/010.phpt new file mode 100644 index 0000000000..9f423a7c1e --- /dev/null +++ b/Zend/tests/nullsafe_operator/010.phpt @@ -0,0 +1,11 @@ +--TEST-- +Test fetch nested nullsafe property by ref +--FILE-- +<?php + +$foo = null; +$ref = &$foo?->bar->baz; + +?> +--EXPECTF-- +Fatal error: Cannot take reference of a nullsafe chain in %s.php on line 4 diff --git a/Zend/tests/nullsafe_operator/011.phpt b/Zend/tests/nullsafe_operator/011.phpt new file mode 100644 index 0000000000..61d60011f7 --- /dev/null +++ b/Zend/tests/nullsafe_operator/011.phpt @@ -0,0 +1,54 @@ +--TEST-- +Test isset and empty on nullsafe property +--FILE-- +<?php + +class Foo { + public $bar; +} + +class Bar { + public $baz; +} +$bar = new Bar(); +$bar->baz = 'baz'; + +var_dump(isset($foo?->bar)); +var_dump(empty($foo?->bar)); + +var_dump(isset($foo?->bar->baz)); +var_dump(empty($foo?->bar->baz)); +echo "\n"; + +$foo = null; +var_dump(isset($foo?->bar)); +var_dump(empty($foo?->bar)); + +var_dump(isset($foo?->bar->baz)); +var_dump(empty($foo?->bar->baz)); +echo "\n"; + +$foo = new Foo(); +var_dump(isset($foo?->bar->baz)); +var_dump(empty($foo?->bar->baz)); + +$foo->bar = $bar; +var_dump(isset($foo?->bar->baz)); +var_dump(empty($foo?->bar->baz)); + +?> +--EXPECT-- +bool(false) +bool(true) +bool(false) +bool(true) + +bool(false) +bool(true) +bool(false) +bool(true) + +bool(false) +bool(true) +bool(true) +bool(false) diff --git a/Zend/tests/nullsafe_operator/012.phpt b/Zend/tests/nullsafe_operator/012.phpt new file mode 100644 index 0000000000..a91e7652ca --- /dev/null +++ b/Zend/tests/nullsafe_operator/012.phpt @@ -0,0 +1,18 @@ +--TEST-- +Test nullsafe property on reference +--FILE-- +<?php + +class Foo { + public $bar; +} + +$foo = new Foo(); +$foo->bar = 'bar'; + +$fooRef = &$foo; +var_dump($fooRef?->bar); + +?> +--EXPECT-- +string(3) "bar" diff --git a/Zend/tests/nullsafe_operator/013.phpt b/Zend/tests/nullsafe_operator/013.phpt new file mode 100644 index 0000000000..1210113774 --- /dev/null +++ b/Zend/tests/nullsafe_operator/013.phpt @@ -0,0 +1,67 @@ +--TEST-- +Test nullsafe property in special functions +--FILE-- +<?php + +function dump_error(callable $callable) { + try { + var_dump($callable()); + } catch (Throwable $e) { + var_dump($e->getMessage()); + } +} + +function foo() {} + +$foo = null; +dump_error(fn() => strlen($foo?->foo())); +dump_error(fn() => is_null($foo?->foo())); +dump_error(fn() => is_bool($foo?->foo())); +dump_error(fn() => is_int($foo?->foo())); +dump_error(fn() => is_scalar($foo?->foo())); +dump_error(fn() => boolval($foo?->foo())); +dump_error(fn() => defined($foo?->foo())); +dump_error(fn() => chr($foo?->foo())); +dump_error(fn() => ord($foo?->foo())); +dump_error(fn() => call_user_func_array($foo?->foo(), [])); +dump_error(fn() => call_user_func_array('foo', $foo?->foo())); +dump_error(fn() => get_class($foo?->foo())); +dump_error(fn() => get_called_class($foo?->foo())); +dump_error(fn() => gettype($foo?->foo())); +dump_error(fn() => func_num_args($foo?->foo())); +dump_error(fn() => func_get_args($foo?->foo())); +dump_error(fn() => array_slice($foo?->foo(), 0)); +dump_error(fn() => array_slice(['foo'], $foo?->foo())); +dump_error(fn() => array_slice(['foo'], 0, $foo?->foo())); +dump_error(fn() => array_key_exists($foo?->foo(), [])); +dump_error(fn() => array_key_exists('foo', $foo?->foo())); + +?> +--EXPECTF-- +int(0) +bool(true) +bool(false) +bool(false) +bool(false) +bool(false) +bool(false) +string(1) "%s" +int(0) +string(98) "call_user_func_array(): Argument #1 ($function) must be a valid callback, no array or string given" +string(77) "call_user_func_array(): Argument #2 ($args) must be of type array, null given" +string(69) "get_class(): Argument #1 ($object) must be of type object, null given" +string(56) "get_called_class() expects exactly 0 parameters, 1 given" +string(4) "NULL" +string(53) "func_num_args() expects exactly 0 parameters, 1 given" +string(53) "func_get_args() expects exactly 0 parameters, 1 given" +string(67) "array_slice(): Argument #1 ($arg) must be of type array, null given" +array(1) { + [0]=> + string(3) "foo" +} +array(1) { + [0]=> + string(3) "foo" +} +bool(false) +string(74) "array_key_exists(): Argument #2 ($array) must be of type array, null given" diff --git a/Zend/tests/nullsafe_operator/014.phpt b/Zend/tests/nullsafe_operator/014.phpt new file mode 100644 index 0000000000..896e831ec9 --- /dev/null +++ b/Zend/tests/nullsafe_operator/014.phpt @@ -0,0 +1,47 @@ +--TEST-- +Test nullsafe in binary op +--FILE-- +<?php + +function try_and_dump($fn) { + try { + var_dump($fn()); + } catch (\Error $e) { + echo $e->getMessage() . "\n"; + } +} + +class Foo { + public function bar() { + echo "bar\n"; + } +} + +$foo = new Foo(); +$null = null; + +try_and_dump(fn() => $null?->null() + $null?->null()); +try_and_dump(fn() => $foo?->bar() + $null?->null()); +try_and_dump(fn() => $null?->null() + $foo?->bar()); +try_and_dump(fn() => $foo->bar() + $null?->null()); +try_and_dump(fn() => $null?->null() + $foo->bar()); +try_and_dump(fn() => $null?->null() + $null->null()); +try_and_dump(fn() => $null->null() + $null?->null()); +try_and_dump(fn() => ($foo?->bar() + $foo?->bar())?->baz()); + +?> +--EXPECT-- +int(0) +bar +int(0) +bar +int(0) +bar +int(0) +bar +int(0) +Call to a member function null() on null +Call to a member function null() on null +bar +bar +Call to a member function baz() on int diff --git a/Zend/tests/nullsafe_operator/015.phpt b/Zend/tests/nullsafe_operator/015.phpt new file mode 100644 index 0000000000..f63758e759 --- /dev/null +++ b/Zend/tests/nullsafe_operator/015.phpt @@ -0,0 +1,12 @@ +--TEST-- +Test nullsafe in binary op +--FILE-- +<?php + +(new stdClass)->{null?->x}->y; + +?> +--EXPECTF-- +Warning: Undefined property: stdClass::$ in %s on line 3 + +Warning: Attempt to read property "y" on null in %s on line 3 diff --git a/Zend/tests/nullsafe_operator/016.phpt b/Zend/tests/nullsafe_operator/016.phpt new file mode 100644 index 0000000000..28bdd08458 --- /dev/null +++ b/Zend/tests/nullsafe_operator/016.phpt @@ -0,0 +1,35 @@ +--TEST-- +Test nullsafe in function argument +--FILE-- +<?php + +class Foo { + public $bar; +} + +function set(&$ref, $value) { + $ref = $value; +} + +function test($foo) { + try { + set($foo?->bar, 'bar'); + } catch (Error $e) { + echo $e->getMessage() . "\n"; + } + try { + (strrev('tes'))($foo?->bar, 'bar2'); + } catch (Error $e) { + echo $e->getMessage() . "\n"; + } +} + +test(null); +test(new Foo()); + +?> +--EXPECT-- +Cannot pass parameter 1 by reference +Cannot pass parameter 1 by reference +Cannot pass parameter 1 by reference +Cannot pass parameter 1 by reference diff --git a/Zend/tests/nullsafe_operator/017.phpt b/Zend/tests/nullsafe_operator/017.phpt new file mode 100644 index 0000000000..b38a371bf0 --- /dev/null +++ b/Zend/tests/nullsafe_operator/017.phpt @@ -0,0 +1,12 @@ +--TEST-- +Test return nullsafe as ref +--FILE-- +<?php + +function &get_bar_ref($foo) { + return $foo?->bar; +} + +?> +--EXPECTF-- +Fatal error: Cannot take reference of a nullsafe chain in %s.php on line 4 diff --git a/Zend/tests/nullsafe_operator/018.phpt b/Zend/tests/nullsafe_operator/018.phpt new file mode 100644 index 0000000000..8d018f53bf --- /dev/null +++ b/Zend/tests/nullsafe_operator/018.phpt @@ -0,0 +1,19 @@ +--TEST-- +Test nullsafe on undefined variable +--FILE-- +<?php + +var_dump($foo?->bar); +var_dump($foo?->bar()); +var_dump($foo); + +?> +--EXPECTF-- +Warning: Undefined variable $foo in %s.php on line 3 +NULL + +Warning: Undefined variable $foo in %s.php on line 4 +NULL + +Warning: Undefined variable $foo in %s.php on line 5 +NULL diff --git a/Zend/tests/nullsafe_operator/019.phpt b/Zend/tests/nullsafe_operator/019.phpt new file mode 100644 index 0000000000..3b1982afa3 --- /dev/null +++ b/Zend/tests/nullsafe_operator/019.phpt @@ -0,0 +1,27 @@ +--TEST-- +Test nullsafe in new +--FILE-- +<?php + +class Bar {} + +class Foo { + public $bar; +} + +$foo = new Foo(); +$foo->bar = 'bar'; +var_dump(new $foo?->bar); + +$foo = null; +var_dump(new $foo?->bar); + +?> +--EXPECTF-- +object(Bar)#2 (0) { +} + +Fatal error: Uncaught Error: Class name must be a valid object or a string in %s.php:14 +Stack trace: +#0 {main} + thrown in %s.php on line 14 diff --git a/Zend/tests/nullsafe_operator/020.phpt b/Zend/tests/nullsafe_operator/020.phpt new file mode 100644 index 0000000000..28cd6db0dc --- /dev/null +++ b/Zend/tests/nullsafe_operator/020.phpt @@ -0,0 +1,18 @@ +--TEST-- +Test nullsafe lhs of assignment to nested property chain +--FILE-- +<?php + +class Foo { + public $bar; +} + +function bar() { + var_dump('called'); +} + +$foo = null; +$foo?->bar->baz = bar(); + +--EXPECTF-- +Fatal error: Can't use nullsafe operator in write context in %s.php on line 12 diff --git a/Zend/tests/nullsafe_operator/021.phpt b/Zend/tests/nullsafe_operator/021.phpt new file mode 100644 index 0000000000..a44aef433d --- /dev/null +++ b/Zend/tests/nullsafe_operator/021.phpt @@ -0,0 +1,21 @@ +--TEST-- +Test nullsafe in list assign +--FILE-- +<?php + +class Foo { + public $bar; +} + +class Bar { + public $baz; +} + +$foo = new Foo(); +$foo->bar = new Bar(); + +[$foo?->bar->baz] = ['bar']; +var_dump($foo); + +--EXPECTF-- +Fatal error: Assignments can only happen to writable values in %s on line %d diff --git a/Zend/tests/nullsafe_operator/022.phpt b/Zend/tests/nullsafe_operator/022.phpt new file mode 100644 index 0000000000..2cda806a36 --- /dev/null +++ b/Zend/tests/nullsafe_operator/022.phpt @@ -0,0 +1,10 @@ +--TEST-- +Test nullsafe in unset +--FILE-- +<?php + +$foo = null; +unset($foo?->bar->baz); + +--EXPECTF-- +Fatal error: Can't use nullsafe operator in write context in %s.php on line 4 diff --git a/Zend/tests/nullsafe_operator/023.phpt b/Zend/tests/nullsafe_operator/023.phpt new file mode 100644 index 0000000000..15007c8de9 --- /dev/null +++ b/Zend/tests/nullsafe_operator/023.phpt @@ -0,0 +1,44 @@ +--TEST-- +Foreach by reference on nullsafe +--FILE-- +<?php + +class Foo { + public $bar; +} + +$foo = new Foo(); + +foreach ($foo?->bar as &$value) { + var_dump($value); +} + +// Don't convert $foo->bar into a reference. +$foo->bar = [42]; +foreach ($foo?->bar as &$value) { + var_dump($value); + $value++; +} +var_dump($foo->bar); + +// But respect interior references. +$ref =& $foo->bar[0]; +foreach ($foo?->bar as &$value) { + var_dump($value); + $value++; +} +var_dump($foo->bar); + +?> +--EXPECTF-- +Warning: foreach() argument must be of type array|object, null given in %s on line %d +int(42) +array(1) { + [0]=> + int(42) +} +int(42) +array(1) { + [0]=> + &int(43) +} diff --git a/Zend/tests/nullsafe_operator/024.phpt b/Zend/tests/nullsafe_operator/024.phpt new file mode 100644 index 0000000000..2d4d86caea --- /dev/null +++ b/Zend/tests/nullsafe_operator/024.phpt @@ -0,0 +1,10 @@ +--TEST-- +Test nullsafe as foreach target +--FILE-- +<?php + +$foo = null; +foreach ([1, 2, 3] as $foo?->bar) {} + +--EXPECTF-- +Fatal error: Can't use nullsafe operator in write context in %s.php on line 4 diff --git a/Zend/tests/nullsafe_operator/025.phpt b/Zend/tests/nullsafe_operator/025.phpt new file mode 100644 index 0000000000..eadb906866 --- /dev/null +++ b/Zend/tests/nullsafe_operator/025.phpt @@ -0,0 +1,14 @@ +--TEST-- +Nullsafe chains in variable variables +--FILE-- +<?php + +$a = null; +var_dump(${$a?->b}->c); + +?> +--EXPECTF-- +Warning: Undefined variable $ in %s on line %d + +Warning: Attempt to read property "c" on null in %s on line %d +NULL diff --git a/Zend/tests/nullsafe_operator/026.phpt b/Zend/tests/nullsafe_operator/026.phpt new file mode 100644 index 0000000000..c4e825febb --- /dev/null +++ b/Zend/tests/nullsafe_operator/026.phpt @@ -0,0 +1,26 @@ +--TEST-- +Nullsafe chain in static property / method name +--FILE-- +<?php + +class Test { +} + +$null = null; + +try { + Test::${$null?->foo}->bar; +} catch (Error $e) { + echo $e->getMessage(), "\n"; +} + +try { + Test::{$null?->foo}()->bar; +} catch (Error $e) { + echo $e->getMessage(), "\n"; +} + +?> +--EXPECT-- +Access to undeclared static property Test::$ +Method name must be a string diff --git a/Zend/tests/nullsafe_operator/027.phpt b/Zend/tests/nullsafe_operator/027.phpt new file mode 100644 index 0000000000..9e08a562c2 --- /dev/null +++ b/Zend/tests/nullsafe_operator/027.phpt @@ -0,0 +1,23 @@ +--TEST-- +Test nullsafe in sub-chain of function argument +--FILE-- +<?php + +function takes_ref(&$foo) { + $foo = 'foo'; +} + +function &returns_ref($ref) { + global $foo; + return $foo; +} + +global $foo; + +$null = null; +takes_ref(returns_ref($null?->null())); +var_dump($foo); + +?> +--EXPECT-- +string(3) "foo" diff --git a/Zend/tests/nullsafe_operator/028.phpt b/Zend/tests/nullsafe_operator/028.phpt new file mode 100644 index 0000000000..e85c014b65 --- /dev/null +++ b/Zend/tests/nullsafe_operator/028.phpt @@ -0,0 +1,24 @@ +--TEST-- +Test nullsafe in sub-chain of return as ref +--FILE-- +<?php + +function &returns_ref($unused) { + global $foo; + return $foo; +} + +function &returns_ref2() { + $null = null; + return returns_ref($null?->null); +} + +global $foo; + +$foo2 = &returns_ref2(); +$foo2 = 'foo'; +var_dump($foo); + +?> +--EXPECT-- +string(3) "foo" diff --git a/Zend/zend_ast.h b/Zend/zend_ast.h index 13f43bdc41..79af596f24 100644 --- a/Zend/zend_ast.h +++ b/Zend/zend_ast.h @@ -108,6 +108,7 @@ enum _zend_ast_kind { /* 2 child nodes */ ZEND_AST_DIM = 2 << ZEND_AST_NUM_CHILDREN_SHIFT, ZEND_AST_PROP, + ZEND_AST_NULLSAFE_PROP, ZEND_AST_STATIC_PROP, ZEND_AST_CALL, ZEND_AST_CLASS_CONST, @@ -147,6 +148,7 @@ enum _zend_ast_kind { /* 3 child nodes */ ZEND_AST_METHOD_CALL = 3 << ZEND_AST_NUM_CHILDREN_SHIFT, + ZEND_AST_NULLSAFE_METHOD_CALL, ZEND_AST_STATIC_CALL, ZEND_AST_CONDITIONAL, diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index d555297c17..c21fb419b9 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -368,6 +368,7 @@ void zend_init_compiler_data_structures(void) /* {{{ */ { zend_stack_init(&CG(loop_var_stack), sizeof(zend_loop_var)); zend_stack_init(&CG(delayed_oplines_stack), sizeof(zend_op)); + zend_stack_init(&CG(short_circuiting_opnums), sizeof(uint32_t)); CG(active_class_entry) = NULL; CG(in_compilation) = 0; CG(skip_shebang) = 0; @@ -421,6 +422,7 @@ void shutdown_compiler(void) /* {{{ */ { zend_stack_destroy(&CG(loop_var_stack)); zend_stack_destroy(&CG(delayed_oplines_stack)); + zend_stack_destroy(&CG(short_circuiting_opnums)); zend_hash_destroy(&CG(filenames_table)); zend_arena_destroy(CG(arena)); @@ -2168,6 +2170,7 @@ static inline void zend_update_jump_target(uint32_t opnum_jump, uint32_t opnum_t case ZEND_JMPNZ_EX: case ZEND_JMP_SET: case ZEND_COALESCE: + case ZEND_JMP_NULL: opline->op2.opline_num = opnum_target; break; EMPTY_SWITCH_DEFAULT_CASE() @@ -2224,6 +2227,91 @@ static zend_op *zend_delayed_compile_end(uint32_t offset) /* {{{ */ } /* }}} */ +static zend_bool zend_ast_kind_is_short_circuited(zend_ast_kind ast_kind) +{ + switch (ast_kind) { + case ZEND_AST_DIM: + case ZEND_AST_PROP: + case ZEND_AST_NULLSAFE_PROP: + case ZEND_AST_STATIC_PROP: + case ZEND_AST_METHOD_CALL: + case ZEND_AST_NULLSAFE_METHOD_CALL: + case ZEND_AST_STATIC_CALL: + return 1; + default: + return 0; + } +} + +static zend_bool zend_ast_is_short_circuited(const zend_ast *ast) +{ + switch (ast->kind) { + case ZEND_AST_DIM: + case ZEND_AST_PROP: + case ZEND_AST_STATIC_PROP: + case ZEND_AST_METHOD_CALL: + case ZEND_AST_STATIC_CALL: + return zend_ast_is_short_circuited(ast->child[0]); + case ZEND_AST_NULLSAFE_PROP: + case ZEND_AST_NULLSAFE_METHOD_CALL: + return 1; + default: + return 0; + } +} + +/* Mark nodes that are an inner part of a short-circuiting chain. + * We should not perform a "commit" on them, as it will be performed by the outer-most node. + * We do this to avoid passing down an argument in various compile functions. */ + +#define ZEND_SHORT_CIRCUITING_INNER 0x8000 + +static void zend_short_circuiting_mark_inner(zend_ast *ast) { + if (zend_ast_kind_is_short_circuited(ast->kind)) { + ast->attr |= ZEND_SHORT_CIRCUITING_INNER; + } +} + +static uint32_t zend_short_circuiting_checkpoint() +{ + return zend_stack_count(&CG(short_circuiting_opnums)); +} + +static void zend_short_circuiting_commit(uint32_t checkpoint, znode *result, zend_ast *ast) +{ + zend_bool is_short_circuited = zend_ast_kind_is_short_circuited(ast->kind) + || ast->kind == ZEND_AST_ISSET || ast->kind == ZEND_AST_EMPTY; + if (!is_short_circuited) { + ZEND_ASSERT(zend_stack_count(&CG(short_circuiting_opnums)) == checkpoint + && "Short circuiting stack should be empty"); + return; + } + + if (ast->attr & ZEND_SHORT_CIRCUITING_INNER) { + /* Outer-most node will commit. */ + return; + } + + while (zend_stack_count(&CG(short_circuiting_opnums)) != checkpoint) { + uint32_t opnum = *(uint32_t *) zend_stack_top(&CG(short_circuiting_opnums)); + zend_op *opline = &CG(active_op_array)->opcodes[opnum]; + opline->op2.opline_num = get_next_op_number(); + SET_NODE(opline->result, result); + opline->extended_value = + ast->kind == ZEND_AST_ISSET ? ZEND_SHORT_CIRCUITING_CHAIN_ISSET : + ast->kind == ZEND_AST_EMPTY ? ZEND_SHORT_CIRCUITING_CHAIN_EMPTY : + ZEND_SHORT_CIRCUITING_CHAIN_EXPR; + zend_stack_del_top(&CG(short_circuiting_opnums)); + } +} + +static void zend_emit_jmp_null(znode *obj_node) +{ + uint32_t jmp_null_opnum = get_next_op_number(); + zend_emit_op(NULL, ZEND_JMP_NULL, obj_node, NULL); + zend_stack_push(&CG(short_circuiting_opnums), &jmp_null_opnum); +} + #define ZEND_MEMOIZE_NONE 0 #define ZEND_MEMOIZE_COMPILE 1 #define ZEND_MEMOIZE_FETCH 2 @@ -2353,8 +2441,11 @@ void zend_emit_final_return(int return_one) /* {{{ */ static inline zend_bool zend_is_variable(zend_ast *ast) /* {{{ */ { - return ast->kind == ZEND_AST_VAR || ast->kind == ZEND_AST_DIM - || ast->kind == ZEND_AST_PROP || ast->kind == ZEND_AST_STATIC_PROP; + return ast->kind == ZEND_AST_VAR + || ast->kind == ZEND_AST_DIM + || ast->kind == ZEND_AST_PROP + || ast->kind == ZEND_AST_NULLSAFE_PROP + || ast->kind == ZEND_AST_STATIC_PROP; } /* }}} */ @@ -2362,6 +2453,7 @@ static inline zend_bool zend_is_call(zend_ast *ast) /* {{{ */ { return ast->kind == ZEND_AST_CALL || ast->kind == ZEND_AST_METHOD_CALL + || ast->kind == ZEND_AST_NULLSAFE_METHOD_CALL || ast->kind == ZEND_AST_STATIC_CALL; } /* }}} */ @@ -2382,11 +2474,14 @@ static inline zend_bool zend_is_unticked_stmt(zend_ast *ast) /* {{{ */ static inline zend_bool zend_can_write_to_variable(zend_ast *ast) /* {{{ */ { - while (ast->kind == ZEND_AST_DIM || ast->kind == ZEND_AST_PROP) { + while ( + ast->kind == ZEND_AST_DIM + || ast->kind == ZEND_AST_PROP + ) { ast = ast->child[0]; } - return zend_is_variable_or_call(ast); + return zend_is_variable_or_call(ast) && !zend_ast_is_short_circuited(ast); } /* }}} */ @@ -2620,7 +2715,7 @@ static inline void zend_emit_assign_znode(zend_ast *var_ast, znode *value_node) znode dummy_node; zend_ast *assign_ast = zend_ast_create(ZEND_AST_ASSIGN, var_ast, zend_ast_create_znode(value_node)); - zend_compile_assign(&dummy_node, assign_ast); + zend_compile_expr(&dummy_node, assign_ast); zend_do_free(&dummy_node); } /* }}} */ @@ -2636,6 +2731,7 @@ static zend_op *zend_delayed_compile_dim(znode *result, zend_ast *ast, uint32_t znode var_node, dim_node; + zend_short_circuiting_mark_inner(var_ast); opline = zend_delayed_compile_var(&var_node, var_ast, type, 0); if (opline && type == BP_VAR_W && (opline->opcode == ZEND_FETCH_STATIC_PROP_W || opline->opcode == ZEND_FETCH_OBJ_W)) { opline->extended_value |= ZEND_FETCH_DIM_WRITE; @@ -2680,6 +2776,7 @@ static zend_op *zend_delayed_compile_prop(znode *result, zend_ast *ast, uint32_t znode obj_node, prop_node; zend_op *opline; + zend_bool nullsafe = ast->kind == ZEND_AST_NULLSAFE_PROP; if (is_this_fetch(obj_ast)) { if (this_guaranteed_exists()) { @@ -2689,9 +2786,15 @@ static zend_op *zend_delayed_compile_prop(znode *result, zend_ast *ast, uint32_t } CG(active_op_array)->fn_flags |= ZEND_ACC_USES_THIS; } else { + zend_short_circuiting_mark_inner(obj_ast); opline = zend_delayed_compile_var(&obj_node, obj_ast, type, 0); zend_separate_if_call_and_write(&obj_node, obj_ast, type); } + + if (nullsafe) { + zend_emit_jmp_null(&obj_node); + } + zend_compile_expr(&prop_node, prop_ast); opline = zend_delayed_emit_op(result, ZEND_FETCH_OBJ_R, &obj_node, &prop_node); @@ -2701,6 +2804,7 @@ static zend_op *zend_delayed_compile_prop(znode *result, zend_ast *ast, uint32_t } zend_adjust_for_fetch_type(opline, result, type); + return opline; } /* }}} */ @@ -2724,6 +2828,7 @@ zend_op *zend_compile_static_prop(znode *result, zend_ast *ast, uint32_t type, i znode class_node, prop_node; zend_op *opline; + zend_short_circuiting_mark_inner(class_ast); zend_compile_class_ref(&class_node, class_ast, ZEND_FETCH_CLASS_EXCEPTION); zend_compile_expr(&prop_node, prop_ast); @@ -2891,9 +2996,16 @@ static void zend_ensure_writable_variable(const zend_ast *ast) /* {{{ */ if (ast->kind == ZEND_AST_CALL) { zend_error_noreturn(E_COMPILE_ERROR, "Can't use function return value in write context"); } - if (ast->kind == ZEND_AST_METHOD_CALL || ast->kind == ZEND_AST_STATIC_CALL) { + if ( + ast->kind == ZEND_AST_METHOD_CALL + || ast->kind == ZEND_AST_NULLSAFE_METHOD_CALL + || ast->kind == ZEND_AST_STATIC_CALL + ) { zend_error_noreturn(E_COMPILE_ERROR, "Can't use method return value in write context"); } + if (zend_ast_is_short_circuited(ast)) { + zend_error_noreturn(E_COMPILE_ERROR, "Can't use nullsafe operator in write context"); + } } /* }}} */ @@ -2931,7 +3043,6 @@ void zend_compile_assign(znode *result, zend_ast *ast) /* {{{ */ znode var_node, expr_node; zend_op *opline; uint32_t offset; - if (is_this_fetch(var_ast)) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); } @@ -2984,6 +3095,7 @@ void zend_compile_assign(znode *result, zend_ast *ast) /* {{{ */ opline = zend_emit_op_data(&expr_node); return; case ZEND_AST_PROP: + case ZEND_AST_NULLSAFE_PROP: offset = zend_delayed_compile_begin(); zend_delayed_compile_prop(result, var_ast, BP_VAR_W); zend_compile_expr(&expr_node, expr_ast); @@ -3041,6 +3153,9 @@ void zend_compile_assign_ref(znode *result, zend_ast *ast) /* {{{ */ zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this"); } zend_ensure_writable_variable(target_ast); + if (zend_ast_is_short_circuited(source_ast)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot take reference of a nullsafe chain"); + } offset = zend_delayed_compile_begin(); zend_delayed_compile_var(&target_node, target_ast, BP_VAR_W, 1); @@ -3093,7 +3208,7 @@ static inline void zend_emit_assign_ref_znode(zend_ast *var_ast, znode *value_no { zend_ast *assign_ast = zend_ast_create(ZEND_AST_ASSIGN_REF, var_ast, zend_ast_create_znode(value_node)); - zend_compile_assign_ref(NULL, assign_ast); + zend_compile_expr(NULL, assign_ast); } /* }}} */ @@ -3147,6 +3262,7 @@ void zend_compile_compound_assign(znode *result, zend_ast *ast) /* {{{ */ zend_emit_op_data(&expr_node); return; case ZEND_AST_PROP: + case ZEND_AST_NULLSAFE_PROP: offset = zend_delayed_compile_begin(); zend_delayed_compile_prop(result, var_ast, BP_VAR_RW); zend_compile_expr(&expr_node, expr_ast); @@ -3220,7 +3336,7 @@ uint32_t zend_compile_args(zend_ast *ast, zend_function *fbc) /* {{{ */ opcode = ZEND_SEND_VAR_NO_REF_EX; } } - } else if (zend_is_variable(arg)) { + } else if (zend_is_variable(arg) && !zend_ast_is_short_circuited(arg)) { if (fbc) { if (ARG_SHOULD_BE_SENT_BY_REF(fbc, arg_num)) { zend_compile_var(&arg_node, arg, BP_VAR_W, 1); @@ -4115,6 +4231,7 @@ void zend_compile_method_call(znode *result, zend_ast *ast, uint32_t type) /* {{ znode obj_node, method_node; zend_op *opline; zend_function *fbc = NULL; + zend_bool nullsafe = ast->kind == ZEND_AST_NULLSAFE_METHOD_CALL; if (is_this_fetch(obj_ast)) { if (this_guaranteed_exists()) { @@ -4124,9 +4241,14 @@ void zend_compile_method_call(znode *result, zend_ast *ast, uint32_t type) /* {{ } CG(active_op_array)->fn_flags |= ZEND_ACC_USES_THIS; } else { + zend_short_circuiting_mark_inner(obj_ast); zend_compile_expr(&obj_node, obj_ast); } + if (nullsafe) { + zend_emit_jmp_null(&obj_node); + } + zend_compile_expr(&method_node, method_ast); opline = zend_emit_op(NULL, ZEND_INIT_METHOD_CALL, &obj_node, NULL); @@ -4194,9 +4316,11 @@ void zend_compile_static_call(znode *result, zend_ast *ast, uint32_t type) /* {{ zend_op *opline; zend_function *fbc = NULL; + zend_short_circuiting_mark_inner(class_ast); zend_compile_class_ref(&class_node, class_ast, ZEND_FETCH_CLASS_EXCEPTION); zend_compile_expr(&method_node, method_ast); + if (method_node.op_type == IS_CONST) { zval *name = &method_node.u.constant; if (Z_TYPE_P(name) != IS_STRING) { @@ -4393,6 +4517,7 @@ void zend_compile_unset(zend_ast *ast) /* {{{ */ opline->opcode = ZEND_UNSET_DIM; return; case ZEND_AST_PROP: + case ZEND_AST_NULLSAFE_PROP: opline = zend_compile_prop(NULL, var_ast, BP_VAR_UNSET, 0); opline->opcode = ZEND_UNSET_OBJ; return; @@ -4506,6 +4631,10 @@ void zend_compile_return(zend_ast *ast) /* {{{ */ by_ref = 0; } + if (by_ref && zend_ast_is_short_circuited(expr_ast)) { + zend_error_noreturn(E_COMPILE_ERROR, "Cannot take reference of a nullsafe chain"); + } + if (!expr_ast) { expr_node.op_type = IS_CONST; ZVAL_NULL(&expr_node.u.constant); @@ -4540,7 +4669,7 @@ void zend_compile_return(zend_ast *ast) /* {{{ */ if (by_ref && expr_ast) { if (zend_is_call(expr_ast)) { opline->extended_value = ZEND_RETURNS_FUNCTION; - } else if (!zend_is_variable(expr_ast)) { + } else if (!zend_is_variable(expr_ast) || zend_ast_is_short_circuited(expr_ast)) { opline->extended_value = ZEND_RETURNS_VALUE; } } @@ -7787,6 +7916,7 @@ void zend_compile_binary_op(znode *result, zend_ast *ast) /* {{{ */ uint32_t opcode = ast->attr; znode left_node, right_node; + zend_compile_expr(&left_node, left_ast); zend_compile_expr(&right_node, right_ast); @@ -8003,7 +8133,7 @@ void zend_compile_post_incdec(znode *result, zend_ast *ast) /* {{{ */ zend_ensure_writable_variable(var_ast); - if (var_ast->kind == ZEND_AST_PROP) { + if (var_ast->kind == ZEND_AST_PROP || var_ast->kind == ZEND_AST_NULLSAFE_PROP) { zend_op *opline = zend_compile_prop(NULL, var_ast, BP_VAR_RW, 0); opline->opcode = ast->kind == ZEND_AST_POST_INC ? ZEND_POST_INC_OBJ : ZEND_POST_DEC_OBJ; zend_make_tmp_result(result, opline); @@ -8027,7 +8157,7 @@ void zend_compile_pre_incdec(znode *result, zend_ast *ast) /* {{{ */ zend_ensure_writable_variable(var_ast); - if (var_ast->kind == ZEND_AST_PROP) { + if (var_ast->kind == ZEND_AST_PROP || var_ast->kind == ZEND_AST_NULLSAFE_PROP) { zend_op *opline = zend_compile_prop(result, var_ast, BP_VAR_RW, 0); opline->opcode = ast->kind == ZEND_AST_PRE_INC ? ZEND_PRE_INC_OBJ : ZEND_PRE_DEC_OBJ; opline->result_type = IS_TMP_VAR; @@ -8238,6 +8368,7 @@ void zend_compile_assign_coalesce(znode *result, zend_ast *ast) /* {{{ */ assign_node = var_node_w; break; case ZEND_AST_PROP: + case ZEND_AST_NULLSAFE_PROP: opline->opcode = ZEND_ASSIGN_OBJ; opline->result_type = IS_TMP_VAR; var_node_w.op_type = IS_TMP_VAR; @@ -8419,6 +8550,7 @@ void zend_compile_isset_or_empty(znode *result, zend_ast *ast) /* {{{ */ ZEND_ASSERT(ast->kind == ZEND_AST_ISSET || ast->kind == ZEND_AST_EMPTY); + zend_short_circuiting_mark_inner(var_ast); if (!zend_is_variable(var_ast)) { if (ast->kind == ZEND_AST_EMPTY) { /* empty(expr) can be transformed to !expr */ @@ -8449,6 +8581,7 @@ void zend_compile_isset_or_empty(znode *result, zend_ast *ast) /* {{{ */ opline->opcode = ZEND_ISSET_ISEMPTY_DIM_OBJ; break; case ZEND_AST_PROP: + case ZEND_AST_NULLSAFE_PROP: opline = zend_compile_prop(result, var_ast, BP_VAR_IS, 0); opline->opcode = ZEND_ISSET_ISEMPTY_PROP_OBJ; break; @@ -9165,7 +9298,7 @@ void zend_compile_stmt(zend_ast *ast) /* {{{ */ zend_compile_halt_compiler(ast); break; case ZEND_AST_THROW: - zend_compile_throw(NULL, ast); + zend_compile_expr(NULL, ast); break; default: { @@ -9181,7 +9314,7 @@ void zend_compile_stmt(zend_ast *ast) /* {{{ */ } /* }}} */ -void zend_compile_expr(znode *result, zend_ast *ast) /* {{{ */ +static void zend_compile_expr_inner(znode *result, zend_ast *ast) /* {{{ */ { /* CG(zend_lineno) = ast->lineno; */ CG(zend_lineno) = zend_ast_get_lineno(ast); @@ -9202,9 +9335,11 @@ void zend_compile_expr(znode *result, zend_ast *ast) /* {{{ */ case ZEND_AST_VAR: case ZEND_AST_DIM: case ZEND_AST_PROP: + case ZEND_AST_NULLSAFE_PROP: case ZEND_AST_STATIC_PROP: case ZEND_AST_CALL: case ZEND_AST_METHOD_CALL: + case ZEND_AST_NULLSAFE_METHOD_CALL: case ZEND_AST_STATIC_CALL: zend_compile_var(result, ast, BP_VAR_R, 0); return; @@ -9323,7 +9458,14 @@ void zend_compile_expr(znode *result, zend_ast *ast) /* {{{ */ } /* }}} */ -zend_op *zend_compile_var(znode *result, zend_ast *ast, uint32_t type, int by_ref) /* {{{ */ +void zend_compile_expr(znode *result, zend_ast *ast) +{ + uint32_t checkpoint = zend_short_circuiting_checkpoint(); + zend_compile_expr_inner(result, ast); + zend_short_circuiting_commit(checkpoint, result, ast); +} + +static zend_op *zend_compile_var_inner(znode *result, zend_ast *ast, uint32_t type, int by_ref) { CG(zend_lineno) = zend_ast_get_lineno(ast); @@ -9333,6 +9475,7 @@ zend_op *zend_compile_var(znode *result, zend_ast *ast, uint32_t type, int by_re case ZEND_AST_DIM: return zend_compile_dim(result, ast, type); case ZEND_AST_PROP: + case ZEND_AST_NULLSAFE_PROP: return zend_compile_prop(result, ast, type, by_ref); case ZEND_AST_STATIC_PROP: return zend_compile_static_prop(result, ast, type, by_ref, 0); @@ -9340,6 +9483,7 @@ zend_op *zend_compile_var(znode *result, zend_ast *ast, uint32_t type, int by_re zend_compile_call(result, ast, type); return NULL; case ZEND_AST_METHOD_CALL: + case ZEND_AST_NULLSAFE_METHOD_CALL: zend_compile_method_call(result, ast, type); return NULL; case ZEND_AST_STATIC_CALL: @@ -9358,7 +9502,14 @@ zend_op *zend_compile_var(znode *result, zend_ast *ast, uint32_t type, int by_re return NULL; } } -/* }}} */ + +zend_op *zend_compile_var(znode *result, zend_ast *ast, uint32_t type, int by_ref) /* {{{ */ +{ + uint32_t checkpoint = zend_short_circuiting_checkpoint(); + zend_op *opcode = zend_compile_var_inner(result, ast, type, by_ref); + zend_short_circuiting_commit(checkpoint, result, ast); + return opcode; +} zend_op *zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t type, zend_bool by_ref) /* {{{ */ { @@ -9368,6 +9519,7 @@ zend_op *zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t type, z case ZEND_AST_DIM: return zend_delayed_compile_dim(result, ast, type); case ZEND_AST_PROP: + case ZEND_AST_NULLSAFE_PROP: { zend_op *opline = zend_delayed_compile_prop(result, ast, type); if (by_ref) { diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index a3fb59bd3e..d804b998de 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -352,6 +352,10 @@ typedef struct _zend_oparray_context { /* call through internal function handler. e.g. Closure::invoke() */ #define ZEND_ACC_CALL_VIA_HANDLER ZEND_ACC_CALL_VIA_TRAMPOLINE +#define ZEND_SHORT_CIRCUITING_CHAIN_EXPR 0 +#define ZEND_SHORT_CIRCUITING_CHAIN_ISSET 1 +#define ZEND_SHORT_CIRCUITING_CHAIN_EMPTY 2 + char *zend_visibility_string(uint32_t fn_flags); typedef struct _zend_property_info { diff --git a/Zend/zend_globals.h b/Zend/zend_globals.h index a91833cd85..be17a44654 100644 --- a/Zend/zend_globals.h +++ b/Zend/zend_globals.h @@ -130,6 +130,8 @@ struct _zend_compiler_globals { HashTable *delayed_autoloads; uint32_t rtd_key_counter; + + zend_stack short_circuiting_opnums; }; diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y index acb7a3d954..f8b4b6d862 100644 --- a/Zend/zend_language_parser.y +++ b/Zend/zend_language_parser.y @@ -211,6 +211,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %token T_BOOL_CAST "'(bool)'" %token T_UNSET_CAST "'(unset)'" %token T_OBJECT_OPERATOR "'->'" +%token T_NULLSAFE_OBJECT_OPERATOR "'?->'" %token T_DOUBLE_ARROW "'=>'" %token T_COMMENT "comment" %token T_DOC_COMMENT "doc comment" @@ -1300,6 +1301,8 @@ callable_variable: { $$ = zend_ast_create_ex(ZEND_AST_DIM, ZEND_DIM_ALTERNATIVE_SYNTAX, $1, $3); } | array_object_dereferencable T_OBJECT_OPERATOR property_name argument_list { $$ = zend_ast_create(ZEND_AST_METHOD_CALL, $1, $3, $4); } + | array_object_dereferencable T_NULLSAFE_OBJECT_OPERATOR property_name argument_list + { $$ = zend_ast_create(ZEND_AST_NULLSAFE_METHOD_CALL, $1, $3, $4); } | function_call { $$ = $1; } ; @@ -1310,6 +1313,8 @@ variable: { $$ = $1; } | array_object_dereferencable T_OBJECT_OPERATOR property_name { $$ = zend_ast_create(ZEND_AST_PROP, $1, $3); } + | array_object_dereferencable T_NULLSAFE_OBJECT_OPERATOR property_name + { $$ = zend_ast_create(ZEND_AST_NULLSAFE_PROP, $1, $3); } ; simple_variable: @@ -1334,6 +1339,8 @@ new_variable: { $$ = zend_ast_create_ex(ZEND_AST_DIM, ZEND_DIM_ALTERNATIVE_SYNTAX, $1, $3); } | new_variable T_OBJECT_OPERATOR property_name { $$ = zend_ast_create(ZEND_AST_PROP, $1, $3); } + | new_variable T_NULLSAFE_OBJECT_OPERATOR property_name + { $$ = zend_ast_create(ZEND_AST_NULLSAFE_PROP, $1, $3); } | class_name T_PAAMAYIM_NEKUDOTAYIM simple_variable { $$ = zend_ast_create(ZEND_AST_STATIC_PROP, $1, $3); } | new_variable T_PAAMAYIM_NEKUDOTAYIM simple_variable @@ -1408,6 +1415,9 @@ encaps_var: | T_VARIABLE T_OBJECT_OPERATOR T_STRING { $$ = zend_ast_create(ZEND_AST_PROP, zend_ast_create(ZEND_AST_VAR, $1), $3); } + | T_VARIABLE T_NULLSAFE_OBJECT_OPERATOR T_STRING + { $$ = zend_ast_create(ZEND_AST_NULLSAFE_PROP, + zend_ast_create(ZEND_AST_VAR, $1), $3); } | T_DOLLAR_OPEN_CURLY_BRACES expr '}' { $$ = zend_ast_create(ZEND_AST_VAR, $2); } | T_DOLLAR_OPEN_CURLY_BRACES T_STRING_VARNAME '}' diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l index 2ebe92e6bd..3b6cc1dd67 100644 --- a/Zend/zend_language_scanner.l +++ b/Zend/zend_language_scanner.l @@ -1573,6 +1573,11 @@ NEWLINE ("\r"|"\n"|"\r\n") RETURN_TOKEN(T_OBJECT_OPERATOR); } +<ST_IN_SCRIPTING>"?->" { + yy_push_state(ST_LOOKING_FOR_PROPERTY); + return T_NULLSAFE_OBJECT_OPERATOR; +} + <ST_IN_SCRIPTING,ST_LOOKING_FOR_PROPERTY>{WHITESPACE}+ { goto return_whitespace; } @@ -1581,6 +1586,10 @@ NEWLINE ("\r"|"\n"|"\r\n") RETURN_TOKEN(T_OBJECT_OPERATOR); } +<ST_LOOKING_FOR_PROPERTY>"?->" { + RETURN_TOKEN(T_NULLSAFE_OBJECT_OPERATOR); +} + <ST_LOOKING_FOR_PROPERTY>{LABEL} { yy_pop_state(); RETURN_TOKEN_WITH_STR(T_STRING, 0); diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c index 06f2b9b19d..14dd6e46db 100644 --- a/Zend/zend_opcode.c +++ b/Zend/zend_opcode.c @@ -1008,6 +1008,7 @@ ZEND_API int pass_two(zend_op_array *op_array) case ZEND_COALESCE: case ZEND_FE_RESET_R: case ZEND_FE_RESET_RW: + case ZEND_JMP_NULL: ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, opline, opline->op2); break; case ZEND_ASSERT_CHECK: diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 10266f4792..e69075bd88 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -7045,6 +7045,39 @@ ZEND_VM_COLD_CONST_HANDLER(169, ZEND_COALESCE, CONST|TMP|VAR|CV, JMP_ADDR) ZEND_VM_NEXT_OPCODE(); } +ZEND_VM_HOT_NOCONST_HANDLER(198, ZEND_JMP_NULL, CONST|TMPVARCV, JMP_ADDR) +{ + USE_OPLINE + zval *val; + + val = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R); + + if (Z_TYPE_INFO_P(val) > IS_NULL) { + ZEND_VM_NEXT_OPCODE(); + } else { + zval *result = EX_VAR(opline->result.var); + + if (EXPECTED(opline->extended_value == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) { + if (UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + } + + ZVAL_NULL(result); + } else if (opline->extended_value == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) { + ZVAL_FALSE(result); + } else { + ZEND_ASSERT(opline->extended_value == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY); + ZVAL_TRUE(result); + } + + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + } +} + ZEND_VM_HOT_HANDLER(31, ZEND_QM_ASSIGN, CONST|TMP|VAR|CV, ANY) { USE_OPLINE diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index de4b37e9c3..d265a266f2 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -4274,6 +4274,39 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_COALESCE_SPEC_CON ZEND_VM_NEXT_OPCODE(); } +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *val; + + val = RT_CONSTANT(opline, opline->op1); + + if (Z_TYPE_INFO_P(val) > IS_NULL) { + ZEND_VM_NEXT_OPCODE(); + } else { + zval *result = EX_VAR(opline->result.var); + + if (EXPECTED(opline->extended_value == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) { + if (UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + } + + ZVAL_NULL(result); + } else if (opline->extended_value == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) { + ZVAL_FALSE(result); + } else { + ZEND_ASSERT(opline->extended_value == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY); + ZVAL_TRUE(result); + } + + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + } +} + static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -10799,6 +10832,39 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BW_NOT_SPEC_TMPVAR ZEND_VM_TAIL_CALL(zend_bw_not_helper_SPEC(op1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC)); } +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_JMP_NULL_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *val; + + val = EX_VAR(opline->op1.var); + + if (Z_TYPE_INFO_P(val) > IS_NULL) { + ZEND_VM_NEXT_OPCODE(); + } else { + zval *result = EX_VAR(opline->result.var); + + if (EXPECTED(opline->extended_value == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) { + if (UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + } + + ZVAL_NULL(result); + } else if (opline->extended_value == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) { + ZVAL_FALSE(result); + } else { + ZEND_ASSERT(opline->extended_value == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY); + ZVAL_TRUE(result); + } + + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + } +} + static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -51130,6 +51196,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL, + (void*)&&ZEND_JMP_NULL_SPEC_CONST_LABEL, + (void*)&&ZEND_JMP_NULL_SPEC_TMPVARCV_LABEL, + (void*)&&ZEND_JMP_NULL_SPEC_TMPVARCV_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_JMP_NULL_SPEC_TMPVARCV_LABEL, (void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL, (void*)&&ZEND_JMP_FORWARD_SPEC_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -52574,6 +52645,10 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_COALESCE_SPEC_CONST) ZEND_COALESCE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_JMP_NULL_SPEC_CONST): + VM_TRACE(ZEND_JMP_NULL_SPEC_CONST) + ZEND_JMP_NULL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_CONST): VM_TRACE(ZEND_QM_ASSIGN_SPEC_CONST) ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -53154,6 +53229,10 @@ zend_leave_helper_SPEC_LABEL: VM_TRACE(ZEND_BW_NOT_SPEC_TMPVARCV) ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); HYBRID_BREAK(); + HYBRID_CASE(ZEND_JMP_NULL_SPEC_TMPVARCV): + VM_TRACE(ZEND_JMP_NULL_SPEC_TMPVARCV) + ZEND_JMP_NULL_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + HYBRID_BREAK(); HYBRID_CASE(ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV): VM_TRACE(ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -58757,6 +58836,11 @@ void zend_vm_init(void) ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER, ZEND_NULL_HANDLER, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER, + ZEND_JMP_NULL_SPEC_CONST_HANDLER, + ZEND_JMP_NULL_SPEC_TMPVARCV_HANDLER, + ZEND_JMP_NULL_SPEC_TMPVARCV_HANDLER, + ZEND_NULL_HANDLER, + ZEND_JMP_NULL_SPEC_TMPVARCV_HANDLER, ZEND_RECV_NOTYPE_SPEC_HANDLER, ZEND_JMP_FORWARD_SPEC_HANDLER, ZEND_NULL_HANDLER, @@ -59861,7 +59945,8 @@ void zend_vm_init(void) 2315 | SPEC_RULE_OP1, 2320 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 2345 | SPEC_RULE_OP1, - 3253 + 2350 | SPEC_RULE_OP1, + 3258 }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -60026,7 +60111,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 = 2352 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2357 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -60034,7 +60119,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 = 2377 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2382 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -60042,7 +60127,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 = 2402 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2407 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -60053,17 +60138,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 = 2427 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2432 | 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 = 2452 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2457 | 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 = 2477 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2482 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -60074,17 +60159,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 = 2502 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2507 | 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 = 2527 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2532 | 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 = 2552 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2557 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -60095,14 +60180,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 = 2577 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2582 | 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 = 2652 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2657 | 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_NOT_IDENTICAL: @@ -60113,14 +60198,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 = 2727 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2732 | 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 = 2802 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2807 | 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 = 2882 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2887 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -60131,12 +60216,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 = 2577 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2582 | 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 = 2652 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2657 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -60147,12 +60232,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 = 2727 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2732 | 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 = 2802 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2807 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -60160,12 +60245,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 = 2887 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 2892 | 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 = 2962 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 2967 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -60173,74 +60258,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 = 3037 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3042 | 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 = 3112 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3117 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3199 | SPEC_RULE_OP1; - } 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))))) { + } else if (op1_info == MAY_BE_DOUBLE) { spec = 3209 | 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 = 3214 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3187 | SPEC_RULE_RETVAL; + spec = 3192 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3189 | SPEC_RULE_RETVAL; + spec = 3194 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3191 | SPEC_RULE_RETVAL; + spec = 3196 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3193 | SPEC_RULE_RETVAL; + spec = 3198 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3195; + spec = 3200; } else if (op1_info == MAY_BE_LONG) { - spec = 3196; + spec = 3201; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3197; + spec = 3202; } else if (op1_info == MAY_BE_LONG) { - spec = 3198; + spec = 3203; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2351; + spec = 2356; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2350; + spec = 2355; } break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3249; + spec = 3254; } break; case ZEND_SEND_VAR_EX: if (op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3244 | SPEC_RULE_OP1; + spec = 3249 | 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 = 3251 | SPEC_RULE_RETVAL; + spec = 3256 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -60248,17 +60333,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 = 3214 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3219 | 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 = 3250; + spec = 3255; } break; case ZEND_SEND_VAR: if ((op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3239 | SPEC_RULE_OP1; + spec = 3244 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index 2b27b4e057..e4eb020539 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -1303,498 +1303,502 @@ _(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) \ + _(2350, ZEND_JMP_NULL_SPEC_CONST) \ + _(2351, ZEND_JMP_NULL_SPEC_TMPVARCV) \ + _(2352, ZEND_JMP_NULL_SPEC_TMPVARCV) \ + _(2354, ZEND_JMP_NULL_SPEC_TMPVARCV) \ + _(2355, ZEND_RECV_NOTYPE_SPEC) \ + _(2356, ZEND_JMP_FORWARD_SPEC) \ _(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) \ + _(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_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2378, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2379, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2381, ZEND_ADD_LONG_NO_OVERFLOW_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) \ + _(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_LONG_SPEC_TMPVARCV_CONST) \ + _(2403, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2404, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2406, ZEND_ADD_LONG_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) \ + _(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) \ + _(2427, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2428, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2429, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2431, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2433, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2434, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2436, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_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) \ + _(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) \ + _(2452, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2453, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2454, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2456, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2458, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2459, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2461, ZEND_SUB_LONG_SPEC_CONST_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) \ + _(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) \ + _(2477, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2478, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2479, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2481, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2483, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2484, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2486, ZEND_SUB_DOUBLE_SPEC_CONST_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) \ + _(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_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2503, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2504, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2506, ZEND_SUB_DOUBLE_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) \ + _(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_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2528, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2529, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2531, ZEND_MUL_LONG_NO_OVERFLOW_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) \ + _(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_LONG_SPEC_TMPVARCV_CONST) \ + _(2553, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2554, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2556, ZEND_MUL_LONG_SPEC_TMPVARCV_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) \ + _(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) \ + _(2577, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2578, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2579, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2581, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2597, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2598, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2599, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2600, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2601, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2602, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2603, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2604, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2605, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2609, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2610, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2611, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2612, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2613, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2614, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2615, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2616, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2617, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2618, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2619, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2620, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2624, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2625, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2626, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2642, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2643, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2644, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2645, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2646, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2647, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2648, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2649, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2650, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2654, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2655, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2656, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2672, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2673, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2674, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2675, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2676, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2677, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2678, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2679, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2680, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2684, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2685, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2686, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2687, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2688, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2689, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2690, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2691, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2692, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2693, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2694, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2695, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2699, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2700, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2701, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2717, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2718, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2719, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2720, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2721, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2722, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2723, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2724, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2725, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2729, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2730, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2731, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2747, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2748, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2749, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2750, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2751, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2752, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2753, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2754, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2755, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2759, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2760, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2761, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2762, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2763, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2764, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2765, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2766, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2767, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2768, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2769, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2770, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2774, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2775, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2776, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2792, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2793, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2794, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2795, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2796, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2797, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2798, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2799, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2800, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2804, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2805, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2806, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2822, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2823, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2824, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2825, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2826, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2827, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2828, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2829, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2830, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2834, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2835, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2836, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2837, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2838, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2839, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2840, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2841, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2842, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2843, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2844, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2845, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2849, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2850, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2851, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2867, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2868, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2869, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2870, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2871, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2872, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2873, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2874, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2875, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2879, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2880, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2881, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2882, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(2886, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(2887, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(2891, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(2895, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(2896, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2897, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2898, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(2899, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2900, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2904, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(2905, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2906, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2907, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(2908, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2909, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2910, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2911, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2912, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2913, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2914, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2915, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2919, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2920, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2921, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2922, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(2923, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2924, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2925, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2926, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2927, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2928, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2929, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2930, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2934, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2935, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2936, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2952, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(2953, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2954, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2955, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2956, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2957, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2958, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2959, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2960, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2964, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2965, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2966, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2970, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2971, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2972, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2973, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2974, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2975, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2979, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2980, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(2981, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(2982, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2983, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2984, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2985, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2986, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2987, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2988, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2989, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2990, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2994, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2995, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2996, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2997, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2998, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2999, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3000, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3001, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3002, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3003, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3004, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3005, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3009, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3010, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3011, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3027, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3028, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3029, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3030, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3031, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3032, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3033, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3034, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3035, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3039, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3040, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3041, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3045, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3046, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3047, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3048, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3049, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3050, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3054, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3055, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3056, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3057, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3058, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3059, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3060, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3061, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3062, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3063, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3064, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3065, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3069, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3070, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3071, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3072, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3073, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3074, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3075, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3076, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3077, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3078, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3079, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3080, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3084, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3085, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3086, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3102, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3103, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3104, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3105, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3106, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3107, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3108, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3109, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3110, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3114, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3115, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3116, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3120, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3121, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3122, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3123, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3124, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3125, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3129, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3130, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3131, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3132, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3133, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3134, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3135, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3136, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3137, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3138, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3139, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3140, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3144, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3145, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3146, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3147, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3148, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3149, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3150, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3151, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3152, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3153, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3154, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3155, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3159, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3160, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3161, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3177, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3178, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3179, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3180, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3181, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3182, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3183, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3184, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3185, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3189, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3190, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3191, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3192, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3193, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3194, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3195, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3196, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3197, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3198, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3199, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3200, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3201, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3202, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3203, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3204, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3205, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3206, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3208, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3209, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3210, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3211, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3213, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3214, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3215, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3216, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3218, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3220, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3221, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3223, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ _(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) + _(3229, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3230, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3231, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3233, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3239, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3240, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3241, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3243, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3246, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3248, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3251, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \ + _(3253, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \ + _(3254, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3255, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3256, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3257, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3257+1, ZEND_NULL) diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index e51e476be3..296a952e12 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -22,7 +22,7 @@ #include <zend.h> #include <zend_vm_opcodes.h> -static const char *zend_vm_opcodes_names[198] = { +static const char *zend_vm_opcodes_names[199] = { "ZEND_NOP", "ZEND_ADD", "ZEND_SUB", @@ -221,9 +221,10 @@ static const char *zend_vm_opcodes_names[198] = { "ZEND_MATCH", "ZEND_CASE_STRICT", "ZEND_MATCH_ERROR", + "ZEND_JMP_NULL", }; -static uint32_t zend_vm_opcodes_flags[198] = { +static uint32_t zend_vm_opcodes_flags[199] = { 0x00000000, 0x00000b0b, 0x00000b0b, @@ -422,6 +423,7 @@ static uint32_t zend_vm_opcodes_flags[198] = { 0x0300030b, 0x00000301, 0x0000010b, + 0x0000200b, }; 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 b196404060..5b203f8d8c 100644 --- a/Zend/zend_vm_opcodes.h +++ b/Zend/zend_vm_opcodes.h @@ -274,7 +274,8 @@ END_EXTERN_C() #define ZEND_MATCH 195 #define ZEND_CASE_STRICT 196 #define ZEND_MATCH_ERROR 197 +#define ZEND_JMP_NULL 198 -#define ZEND_VM_LAST_OPCODE 197 +#define ZEND_VM_LAST_OPCODE 198 #endif |