Implement nullsafe ?-> operator

RFC: https://wiki.php.net/rfc/nullsafe_operator

Closes GH-5619.

Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>

diff --git a/UPGRADING b/UPGRADING
index 8c75319664bd0c40f3166891d3d1b6dfb89849a7..85931d11cf1ef27dd54139e116c69cbea0476517 100644 (file)
--- a/UPGRADING
+++ b/UPGRADING
@@ -607,6 +607,8 @@ PHP 8.0 UPGRADE NOTES
     inheritance rules on the methods of a child class. (with the exception of
     final private constructors)
     RFC: https://wiki.php.net/rfc/inheritance_private_methods
+  . Added support for nullsafe operator (`?->`).
+    RFC: https://wiki.php.net/rfc/nullsafe_operator
 
 - Date:
   . Added DateTime::createFromInterface() and

diff --git a/Zend/tests/nullsafe_operator/001.phpt b/Zend/tests/nullsafe_operator/001.phpt
new file mode 100644 (file)
index 0000000..2277600
--- /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 (file)
index 0000000..46c1bb6
--- /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 (file)
index 0000000..b19c619
--- /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 (file)
index 0000000..0dc95d3
--- /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 (file)
index 0000000..e691401
--- /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 (file)
index 0000000..2cbecd2
--- /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 (file)
index 0000000..a04af8e
--- /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 (file)
index 0000000..360d137
--- /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 (file)
index 0000000..95df9da
--- /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 (file)
index 0000000..9f423a7
--- /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 (file)
index 0000000..61d6001
--- /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 (file)
index 0000000..a91e765
--- /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 (file)
index 0000000..1210113
--- /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 (file)
index 0000000..896e831
--- /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 (file)
index 0000000..f63758e
--- /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 (file)
index 0000000..28bdd08
--- /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 (file)
index 0000000..b38a371
--- /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 (file)
index 0000000..8d018f5
--- /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 (file)
index 0000000..3b1982a
--- /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 (file)
index 0000000..28cd6db
--- /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 (file)
index 0000000..a44aef4
--- /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 (file)
index 0000000..2cda806
--- /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 (file)
index 0000000..15007c8
--- /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 (file)
index 0000000..2d4d86c
--- /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 (file)
index 0000000..eadb906
--- /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 (file)
index 0000000..c4e825f
--- /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 (file)
index 0000000..9e08a56
--- /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 (file)
index 0000000..e85c014
--- /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 13f43bdc413be619b38f19b0122eb41ecae04211..79af596f24c1f38fcbb3fa3537c46f8c9827b812 100644 (file)
--- 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 d555297c17d894b85e2dac43f3e8ba9620a9a60d..c21fb419b9f802fb27918c40c203e62b741aae4f 100644 (file)
--- 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 a3fb59bd3e6d470a07356e0dc5a1a0530fc63887..d804b998dedd13befce2b22ac10225ed77b2baea 100644 (file)
--- 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 a91833cd85010a4198b36e4101d1446e76e78339..be17a446545ae15fa70a29bcbd97d0d1ba858d9d 100644 (file)
--- 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 acb7a3d954ee2cad20f00761ab8c3d49260e0def..f8b4b6d862882b26913315b3d5ef51f61b76ee9e 100644 (file)
--- 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 2ebe92e6bd4bb1dbdf7c89ac8c927ab4720e561e..3b6cc1dd676c7db697c4681e41450fad7852ee91 100644 (file)
--- 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 06f2b9b19d147cfa2d92755b9376f5e72bf0dd7a..14dd6e46db27dc380d8a41a0e336383e59e8a4e0 100644 (file)
--- 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 10266f479222f915b0c4565d007606b35a990930..e69075bd885069da9c1716e4439e08e2edda0646 100644 (file)
--- 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 de4b37e9c37b9fccf943d369d2a6bbb953350de0..d265a266f2c09adbd593606ced722db224743c0b 100644 (file)
--- 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 2b27b4e057874e6f110cb7c6a648de99a0658e4e..e4eb0205391e45e5f495a2a14c7a1f2bbf585d2d 100644 (file)
--- 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 e51e476be30d4a17f116b8b111e03f6a8bfddf71..296a952e127fae7a0887b3ec998f44bcb77f870e 100644 (file)
--- 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 b1964040603110cca382a2ad0adc3e5ed50212bb..5b203f8d8ca63d745d882e7ec8de5d12a763844a 100644 (file)
--- 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

diff --git a/ext/opcache/Optimizer/block_pass.c b/ext/opcache/Optimizer/block_pass.c
index aee3931f0520d7aca27712b2e48431fce1f14d4e..68555115f81ca68dc0c0ae730cb46d23b4d8f82e 100644 (file)
--- a/ext/opcache/Optimizer/block_pass.c
+++ b/ext/opcache/Optimizer/block_pass.c
@@ -1039,6 +1039,7 @@ static void assemble_code_blocks(zend_cfg *cfg, zend_op_array *op_array, zend_op
                        case ZEND_JMP_SET:
                        case ZEND_COALESCE:
                        case ZEND_ASSERT_CHECK:
+                       case ZEND_JMP_NULL:
                                ZEND_SET_OP_JMP_ADDR(opline, opline->op2, new_opcodes + blocks[b->successors[0]].start);
                                break;
                        case ZEND_CATCH:
@@ -1280,6 +1281,7 @@ static void zend_jmp_optimization(zend_basic_block *block, zend_op_array *op_arr
 
                case ZEND_JMP_SET:
                case ZEND_COALESCE:
+               case ZEND_JMP_NULL:
                        jmp_hitlist_count = 0;
 
                        target_block = get_target_block(cfg, block, 0, opt_count);

diff --git a/ext/opcache/Optimizer/dce.c b/ext/opcache/Optimizer/dce.c
index 9f533ea1673925f4971a09f32b06de2e6932317a..c2f7550e91c684b1f7785d664ba46ecba98aad89 100644 (file)
--- a/ext/opcache/Optimizer/dce.c
+++ b/ext/opcache/Optimizer/dce.c
@@ -140,6 +140,7 @@ static inline zend_bool may_have_side_effects(
                case ZEND_JMP_SET:
                case ZEND_COALESCE:
                case ZEND_ASSERT_CHECK:
+               case ZEND_JMP_NULL:
                        /* For our purposes a jumps and branches are side effects. */
                        return 1;
                case ZEND_BEGIN_SILENCE:

diff --git a/ext/opcache/Optimizer/dfa_pass.c b/ext/opcache/Optimizer/dfa_pass.c
index 0b69323980c7ca93af76d2c5fef58fd7e871468e..0605d5f299bd326e45d682bc2deaf3e1586ee017 100644 (file)
--- a/ext/opcache/Optimizer/dfa_pass.c
+++ b/ext/opcache/Optimizer/dfa_pass.c
@@ -622,6 +622,7 @@ static void zend_ssa_replace_control_link(zend_op_array *op_array, zend_ssa *ssa
                        case ZEND_JMP_SET:
                        case ZEND_COALESCE:
                        case ZEND_ASSERT_CHECK:
+                       case ZEND_JMP_NULL:
                                if (ZEND_OP2_JMP_ADDR(opline) == op_array->opcodes + old->start) {
                                        ZEND_SET_OP_JMP_ADDR(opline, opline->op2, op_array->opcodes + dst->start);
                                }
@@ -895,6 +896,28 @@ optimize_jmpnz:
                                        }
                                        break;
                                }
+                               case ZEND_JMP_NULL:
+                               {
+                                       zend_ssa_var *var = &ssa->vars[ssa_op->result_def];
+                                       if (opline->op1_type == IS_CONST
+                                                       && var->use_chain < 0 && var->phi_use_chain == NULL) {
+                                               if (Z_TYPE_P(CT_CONSTANT_EX(op_array, opline->op1.constant)) == IS_NULL) {
+                                                       opline->opcode = ZEND_JMP;
+                                                       opline->result_type = IS_UNUSED;
+                                                       zend_ssa_remove_result_def(ssa, ssa_op);
+                                                       COPY_NODE(opline->op1, opline->op2);
+                                                       take_successor_0(ssa, block_num, block);
+                                                       goto optimize_jmp;
+                                               } else {
+                                                       zend_ssa_remove_result_def(ssa, ssa_op);
+                                                       MAKE_NOP(opline);
+                                                       removed_ops++;
+                                                       take_successor_1(ssa, block_num, block);
+                                                       goto optimize_nop;
+                                               }
+                                       }
+                                       break;
+                               }
                                case ZEND_SWITCH_LONG:
                                case ZEND_SWITCH_STRING:
                                case ZEND_MATCH:

diff --git a/ext/opcache/Optimizer/pass1.c b/ext/opcache/Optimizer/pass1.c
index fee0e1eac36f6987064bfe85cd48d31830d22b24..74f6153670dbf00ff2232ca56689173b3c953434 100644 (file)
--- a/ext/opcache/Optimizer/pass1.c
+++ b/ext/opcache/Optimizer/pass1.c
@@ -676,6 +676,7 @@ constant_binary_op:
                case ZEND_JMP_SET:
                case ZEND_COALESCE:
                case ZEND_ASSERT_CHECK:
+               case ZEND_JMP_NULL:
                        collect_constants = 0;
                        break;
                }

diff --git a/ext/opcache/Optimizer/sccp.c b/ext/opcache/Optimizer/sccp.c
index ee8ccc34a7783aa1d4751fd54bdf3d53d702e43d..1615423abe0170c638896040645f8631bbeb2906 100644 (file)
--- a/ext/opcache/Optimizer/sccp.c
+++ b/ext/opcache/Optimizer/sccp.c
@@ -1781,6 +1781,21 @@ static void sccp_visit_instr(scdf_ctx *scdf, zend_op *opline, zend_ssa_op *ssa_o
                case ZEND_COPY_TMP:
                        SET_RESULT(result, op1);
                        break;
+               case ZEND_JMP_NULL:
+                       switch (opline->extended_value) {
+                               case ZEND_SHORT_CIRCUITING_CHAIN_EXPR:
+                                       ZVAL_NULL(&zv);
+                                       break;
+                               case ZEND_SHORT_CIRCUITING_CHAIN_ISSET:
+                                       ZVAL_FALSE(&zv);
+                                       break;
+                               case ZEND_SHORT_CIRCUITING_CHAIN_EMPTY:
+                                       ZVAL_TRUE(&zv);
+                                       break;
+                               EMPTY_SWITCH_DEFAULT_CASE()
+                       }
+                       SET_RESULT(result, &zv);
+                       break;
 #if 0
                case ZEND_FETCH_CLASS:
                        if (!op1) {
@@ -1979,6 +1994,9 @@ static void sccp_mark_feasible_successors(
                case ZEND_COALESCE:
                        s = (Z_TYPE_P(op1) == IS_NULL);
                        break;
+               case ZEND_JMP_NULL:
+                       s = (Z_TYPE_P(op1) != IS_NULL);
+                       break;
                case ZEND_FE_RESET_R:
                case ZEND_FE_RESET_RW:
                        /* A non-empty partial array is definitely non-empty, but an
@@ -2265,6 +2283,7 @@ static int try_remove_definition(sccp_ctx *ctx, int var_num, zend_ssa_var *var,
                                        || opline->opcode == ZEND_JMPNZ_EX
                                        || opline->opcode == ZEND_JMP_SET
                                        || opline->opcode == ZEND_COALESCE
+                                       || opline->opcode == ZEND_JMP_NULL
                                        || opline->opcode == ZEND_FE_RESET_R
                                        || opline->opcode == ZEND_FE_RESET_RW
                                        || opline->opcode == ZEND_FE_FETCH_R

diff --git a/ext/opcache/Optimizer/zend_cfg.c b/ext/opcache/Optimizer/zend_cfg.c
index d80edda3e1b0d314e17df07692c5b6d4df96e9a9..b8088924f97f445b3abb4ef65f3468e3a1ca1491 100644 (file)
--- a/ext/opcache/Optimizer/zend_cfg.c
+++ b/ext/opcache/Optimizer/zend_cfg.c
@@ -375,6 +375,7 @@ int zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, uint32_t b
                        case ZEND_JMP_SET:
                        case ZEND_COALESCE:
                        case ZEND_ASSERT_CHECK:
+                       case ZEND_JMP_NULL:
                                BB_START(OP_JMP_ADDR(opline, opline->op2) - op_array->opcodes);
                                BB_START(i + 1);
                                break;
@@ -531,6 +532,7 @@ int zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, uint32_t b
                        case ZEND_JMP_SET:
                        case ZEND_COALESCE:
                        case ZEND_ASSERT_CHECK:
+                       case ZEND_JMP_NULL:
                                block->successors_count = 2;
                                block->successors[0] = block_map[OP_JMP_ADDR(opline, opline->op2) - op_array->opcodes];
                                block->successors[1] = j + 1;

diff --git a/ext/opcache/Optimizer/zend_inference.c b/ext/opcache/Optimizer/zend_inference.c
index 8e885e378d13ebc383e4392c61a0214ab971f318..b5208c1fc547eebf2c31e954c3f1cca9702f6998 100644 (file)
--- a/ext/opcache/Optimizer/zend_inference.c
+++ b/ext/opcache/Optimizer/zend_inference.c
@@ -2499,6 +2499,17 @@ static zend_always_inline int _zend_update_type_info(
                        UPDATE_SSA_TYPE(tmp, ssa_op->result_def);
                        COPY_SSA_OBJ_TYPE(ssa_op->op1_use, ssa_op->result_def);
                        break;
+               case ZEND_JMP_NULL:
+                       if (opline->extended_value == ZEND_SHORT_CIRCUITING_CHAIN_EXPR) {
+                               tmp = MAY_BE_NULL;
+                       } else if (opline->extended_value == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) {
+                               tmp = MAY_BE_FALSE;
+                       } else {
+                               ZEND_ASSERT(opline->extended_value == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY);
+                               tmp = MAY_BE_TRUE;
+                       }
+                       UPDATE_SSA_TYPE(tmp, ssa_op->result_def);
+                       break;
                case ZEND_ASSIGN_OP:
                case ZEND_ASSIGN_DIM_OP:
                case ZEND_ASSIGN_OBJ_OP:
@@ -4394,6 +4405,7 @@ int zend_may_throw_ex(const zend_op *opline, const zend_ssa_op *ssa_op, const ze
                case ZEND_COPY_TMP:
                case ZEND_CHECK_FUNC_ARG:
                case ZEND_CASE_STRICT:
+               case ZEND_JMP_NULL:
                        return 0;
                case ZEND_INIT_FCALL:
                        /* can't throw, because call is resolved at compile time */

diff --git a/ext/opcache/Optimizer/zend_optimizer.c b/ext/opcache/Optimizer/zend_optimizer.c
index 78b5893b2f4061274c2d62cc2bede619b5fdbb86..fcfaea0bc5d033a89e2cec44132235180c08da32 100644 (file)
--- a/ext/opcache/Optimizer/zend_optimizer.c
+++ b/ext/opcache/Optimizer/zend_optimizer.c
@@ -683,6 +683,7 @@ void zend_optimizer_migrate_jump(zend_op_array *op_array, zend_op *new_opline, z
                case ZEND_JMP_SET:
                case ZEND_COALESCE:
                case ZEND_ASSERT_CHECK:
+               case ZEND_JMP_NULL:
                        ZEND_SET_OP_JMP_ADDR(new_opline, new_opline->op2, ZEND_OP2_JMP_ADDR(opline));
                        break;
                case ZEND_FE_FETCH_R:
@@ -728,6 +729,7 @@ void zend_optimizer_shift_jump(zend_op_array *op_array, zend_op *opline, uint32_
                case ZEND_JMP_SET:
                case ZEND_COALESCE:
                case ZEND_ASSERT_CHECK:
+               case ZEND_JMP_NULL:
                        ZEND_SET_OP_JMP_ADDR(opline, opline->op2, ZEND_OP2_JMP_ADDR(opline) - shiftlist[ZEND_OP2_JMP_ADDR(opline) - op_array->opcodes]);
                        break;
                case ZEND_CATCH:
@@ -1105,6 +1107,7 @@ static void zend_redo_pass_two(zend_op_array *op_array)
                        case ZEND_FE_RESET_R:
                        case ZEND_FE_RESET_RW:
                        case ZEND_ASSERT_CHECK:
+                       case ZEND_JMP_NULL:
                                opline->op2.jmp_addr = &op_array->opcodes[opline->op2.jmp_addr - old_opcodes];
                                break;
                        case ZEND_CATCH:
@@ -1227,6 +1230,7 @@ static void zend_redo_pass_two_ex(zend_op_array *op_array, zend_ssa *ssa)
                        case ZEND_FE_RESET_R:
                        case ZEND_FE_RESET_RW:
                        case ZEND_ASSERT_CHECK:
+                       case ZEND_JMP_NULL:
                                opline->op2.jmp_addr = &op_array->opcodes[opline->op2.jmp_addr - old_opcodes];
                                break;
                        case ZEND_CATCH:

diff --git a/ext/opcache/Optimizer/zend_ssa.c b/ext/opcache/Optimizer/zend_ssa.c
index 8c2d858e9659e59ee44211e31c3408e781b9cfc3..79de1e2f6611f71a624d39946afa5fcce7a95900 100644 (file)
--- a/ext/opcache/Optimizer/zend_ssa.c
+++ b/ext/opcache/Optimizer/zend_ssa.c
@@ -274,6 +274,14 @@ static void place_essa_pis(
                                        }
                                }
                                continue;
+                       case ZEND_JMP_NULL:
+                               if (opline->op1_type == IS_CV) {
+                                       int var = EX_VAR_TO_NUM(opline->op1.var);
+                                       if ((pi = add_pi(arena, op_array, dfg, ssa, j, blocks[j].successors[1], var))) {
+                                               pi_not_type_mask(pi, MAY_BE_NULL);
+                                       }
+                               }
+                               continue;
                        default:
                                continue;
                }

diff --git a/ext/opcache/jit/zend_jit.c b/ext/opcache/jit/zend_jit.c
index 0115ef78017effc5ee33e007feb0a7d25268f958..0e9a6623fb0a3895201666b800759fa369f87ecb 100644 (file)
--- a/ext/opcache/jit/zend_jit.c
+++ b/ext/opcache/jit/zend_jit.c
@@ -2886,6 +2886,8 @@ static int zend_jit(const zend_op_array *op_array, zend_ssa *ssa, const zend_op
                                                        goto jit_failure;
                                                }
                                                goto done;
+                                       case ZEND_JMP_NULL:
+                                               goto jit_failure;
                                        default:
                                                break;
                                }
@@ -3024,6 +3026,8 @@ static int zend_jit(const zend_op_array *op_array, zend_ssa *ssa, const zend_op
                                                }
                                        }
                                        break;
+                               case ZEND_JMP_NULL:
+                                       goto jit_failure;
                                default:
                                        if (!zend_jit_handler(&dasm_state, opline,
                                                        zend_may_throw(opline, ssa_op, op_array, ssa))) {

diff --git a/ext/opcache/tests/opt/nullsafe_001.phpt b/ext/opcache/tests/opt/nullsafe_001.phpt
new file mode 100644 (file)
index 0000000..37e1d17
--- /dev/null
+++ b/ext/opcache/tests/opt/nullsafe_001.phpt
@@ -0,0 +1,69 @@
+--TEST--
+Nullsafe basic optimization
+--INI--
+opcache.enable=1
+opcache.enable_cli=1
+opcache.opt_debug_level=0x20000
+--SKIPIF--
+<?php require_once(__DIR__ . '/../skipif.inc'); ?>
+--FILE--
+<?php
+
+function test() {
+    $null = null;
+    var_dump($null?->foo);
+    var_dump(isset($null?->foo));
+    var_dump(empty($null?->foo));
+}
+
+function test2(object $obj) {
+    // TODO: Optimize the JMP_NULL away.
+    var_dump($obj?->foo);
+    var_dump(isset($obj?->foo));
+    var_dump(empty($obj?->foo));
+}
+
+?>
+--EXPECTF--
+$_main:
+     ; (lines=1, args=0, vars=0, tmps=0)
+     ; (after optimizer)
+     ; %s
+0000 RETURN int(1)
+
+test:
+     ; (lines=10, args=0, vars=0, tmps=0)
+     ; (after optimizer)
+     ; %s
+0000 INIT_FCALL 1 %d string("var_dump")
+0001 SEND_VAL null 1
+0002 DO_ICALL
+0003 INIT_FCALL 1 %d string("var_dump")
+0004 SEND_VAL bool(false) 1
+0005 DO_ICALL
+0006 INIT_FCALL 1 %d string("var_dump")
+0007 SEND_VAL bool(true) 1
+0008 DO_ICALL
+0009 RETURN null
+
+test2:
+     ; (lines=17, args=1, vars=1, tmps=1)
+     ; (after optimizer)
+     ; %s
+0000 CV0($obj) = RECV 1
+0001 INIT_FCALL 1 %d string("var_dump")
+0002 T1 = JMP_NULL CV0($obj) 0004
+0003 T1 = FETCH_OBJ_R CV0($obj) string("foo")
+0004 SEND_VAL T1 1
+0005 DO_ICALL
+0006 INIT_FCALL 1 %d string("var_dump")
+0007 T1 = JMP_NULL CV0($obj) 0009
+0008 T1 = ISSET_ISEMPTY_PROP_OBJ (isset) CV0($obj) string("foo")
+0009 SEND_VAL T1 1
+0010 DO_ICALL
+0011 INIT_FCALL 1 %d string("var_dump")
+0012 T1 = JMP_NULL CV0($obj) 0014
+0013 T1 = ISSET_ISEMPTY_PROP_OBJ (empty) CV0($obj) string("foo")
+0014 SEND_VAL T1 1
+0015 DO_ICALL
+0016 RETURN null

diff --git a/ext/opcache/tests/opt/nullsafe_002.phpt b/ext/opcache/tests/opt/nullsafe_002.phpt
new file mode 100644 (file)
index 0000000..099fce1
--- /dev/null
+++ b/ext/opcache/tests/opt/nullsafe_002.phpt
@@ -0,0 +1,64 @@
+--TEST--
+Nullsafe e-ssa pi node placement
+--INI--
+opcache.enable=1
+opcache.enable_cli=1
+opcache.opt_debug_level=0x200000
+--SKIPIF--
+<?php require_once(__DIR__ . '/../skipif.inc'); ?>
+--FILE--
+<?php
+
+class Test {
+    public int $prop;
+}
+
+function test(?Test $test) {
+    var_dump($test?->prop);
+}
+
+?>
+--EXPECTF--
+$_main:
+     ; (lines=1, args=0, vars=0, tmps=0, ssa_vars=0, no_loops)
+     ; (before dfa pass)
+     ; %s
+     ; return  [long] RANGE[1..1]
+BB0:
+     ; start exit lines=[0-0]
+     ; level=0
+0000 RETURN int(1)
+
+test:
+     ; (lines=7, args=1, vars=1, tmps=1, ssa_vars=6, no_loops)
+     ; (before dfa pass)
+     ; %s
+     ; return  [null] RANGE[0..0]
+     ; #0.CV0($test) NOVAL [undef]
+BB0:
+     ; start lines=[0-2]
+     ; to=(BB2, BB1)
+     ; level=0
+     ; children=(BB1, BB2)
+0000 #1.CV0($test) [null, object (instanceof Test)] = RECV 1
+0001 INIT_FCALL 1 %d string("var_dump")
+0002 #2.T1 [null] = JMP_NULL #1.CV0($test) [null, object (instanceof Test)] BB2
+
+BB1:
+     ; follow lines=[3-3]
+     ; from=(BB0)
+     ; to=(BB2)
+     ; idom=BB0
+     ; level=1
+     #3.CV0($test) [object (instanceof Test)] = Pi<BB0>(#1.CV0($test) [null, object (instanceof Test)] & TYPE [ref, bool, long, double, string, array of [any, ref], object, resource])
+0003 #4.T1 [long] = FETCH_OBJ_R #3.CV0($test) [object (instanceof Test)] string("prop")
+
+BB2:
+     ; follow target exit lines=[4-6]
+     ; from=(BB0, BB1)
+     ; idom=BB0
+     ; level=1
+     #5.X1 [null, long] = Phi(#2.X1 [null], #4.X1 [long])
+0004 SEND_VAL #5.T1 [null, long] 1
+0005 DO_ICALL
+0006 RETURN null

diff --git a/ext/opcache/zend_file_cache.c b/ext/opcache/zend_file_cache.c
index 379f3fa9a1d22bf357956ffed8539824acdd50bb..81034a38fe9ca60394ea4c56d215cb6a7539f206 100644 (file)
--- a/ext/opcache/zend_file_cache.c
+++ b/ext/opcache/zend_file_cache.c
@@ -536,6 +536,7 @@ static void zend_file_cache_serialize_op_array(zend_op_array            *op_arra
                                case ZEND_FE_RESET_R:
                                case ZEND_FE_RESET_RW:
                                case ZEND_ASSERT_CHECK:
+                               case ZEND_JMP_NULL:
                                        SERIALIZE_PTR(opline->op2.jmp_addr);
                                        break;
                                case ZEND_CATCH:
@@ -1288,6 +1289,7 @@ static void zend_file_cache_unserialize_op_array(zend_op_array           *op_arr
                                case ZEND_FE_RESET_R:
                                case ZEND_FE_RESET_RW:
                                case ZEND_ASSERT_CHECK:
+                               case ZEND_JMP_NULL:
                                        UNSERIALIZE_PTR(opline->op2.jmp_addr);
                                        break;
                                case ZEND_CATCH:

diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c
index 1b2db5f69a034a2df3dad0ff529b4e5019ee1b1a..10631067171298192bf2dc7aabee5e100a1329c5 100644 (file)
--- a/ext/opcache/zend_persist.c
+++ b/ext/opcache/zend_persist.c
@@ -536,6 +536,7 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc
                                        case ZEND_FE_RESET_R:
                                        case ZEND_FE_RESET_RW:
                                        case ZEND_ASSERT_CHECK:
+                                       case ZEND_JMP_NULL:
                                                opline->op2.jmp_addr = &new_opcodes[opline->op2.jmp_addr - op_array->opcodes];
                                                break;
                                        case ZEND_CATCH:

diff --git a/ext/tokenizer/tokenizer_data.c b/ext/tokenizer/tokenizer_data.c
index 9ed027920ccbbdb9fdcf32be37e03da693339a53..049433f4b7b1a509e8faba9871ccfbff93b15c20 100644 (file)
--- a/ext/tokenizer/tokenizer_data.c
+++ b/ext/tokenizer/tokenizer_data.c
@@ -151,6 +151,7 @@ void tokenizer_register_constants(INIT_FUNC_ARGS) {
        REGISTER_LONG_CONSTANT("T_INC", T_INC, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("T_DEC", T_DEC, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("T_OBJECT_OPERATOR", T_OBJECT_OPERATOR, CONST_CS | CONST_PERSISTENT);
+       REGISTER_LONG_CONSTANT("T_NULLSAFE_OBJECT_OPERATOR", T_NULLSAFE_OBJECT_OPERATOR, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("T_COMMENT", T_COMMENT, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("T_DOC_COMMENT", T_DOC_COMMENT, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("T_OPEN_TAG", T_OPEN_TAG, CONST_CS | CONST_PERSISTENT);
@@ -298,6 +299,7 @@ char *get_token_type_name(int token_type)
                case T_INC: return "T_INC";
                case T_DEC: return "T_DEC";
                case T_OBJECT_OPERATOR: return "T_OBJECT_OPERATOR";
+               case T_NULLSAFE_OBJECT_OPERATOR: return "T_NULLSAFE_OBJECT_OPERATOR";
                case T_COMMENT: return "T_COMMENT";
                case T_DOC_COMMENT: return "T_DOC_COMMENT";
                case T_OPEN_TAG: return "T_OPEN_TAG";