Implement typed properties

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

This is a squash of PR #3734, which is a squash of PR #3313.

Co-authored-by: Bob Weinand <bobwei9@hotmail.com>
Co-authored-by: Joe Watkins <krakjoe@php.net>
Co-authored-by: Dmitry Stogov <dmitry@zend.com>

diff --git a/UPGRADING b/UPGRADING
index 835335bb07ec42252ea59f16ca8e00587dc58bb4..be5d6ea0e67755d0516e708c1ad9e6d555876124 100644 (file)
--- a/UPGRADING
+++ b/UPGRADING
@@ -78,8 +78,20 @@ PHP 7.4 UPGRADE NOTES
 2. New Features
 ========================================
 
+- Core:
+  . Added support for typed properties. For example:
+
+        class User {
+            public int $id;
+            public string $name;
+        }
+
+    This will enforce that $user->id can only be assigned integer and
+    $user->name can only be assigned strings. For more information see the
+    RFC: https://wiki.php.net/rfc/typed_properties_v2
+
 - PDO_OCI:
-  . PDOStatement::getColumnMeta is now available
+  . PDOStatement::getColumnMeta() is now available
 
 - PDO_SQLite:
   . PDOStatement::getAttribute(PDO::SQLITE_ATTR_READONLY_STATEMENT) allows to

diff --git a/UPGRADING.INTERNALS b/UPGRADING.INTERNALS
index 2335e766357095d69235f3752c4002f7f472ed97..e4147f249cb70cc5b37727865f8620a6b8056333 100644 (file)
--- a/UPGRADING.INTERNALS
+++ b/UPGRADING.INTERNALS
@@ -13,6 +13,8 @@ PHP 7.4 INTERNALS UPGRADE NOTES
   j. Removed add_get_assoc_*() and add_get_index_*()
   k. Class declaration opcodes
   l. HASH_FLAG_INITIALIZED
+  m. write_property return value
+  n. Assignments to references
 
 2. Build system changes
   a. Abstract
@@ -158,6 +160,17 @@ PHP 7.4 INTERNALS UPGRADE NOTES
      Special HT_IS_INITIALIZED() and HT_INVALIDATE() macro were introduced
      to hide implementation details.
 
+  m. The write_property() object handler now returns the assigned value (after
+     possible type coercions) rather than void. For extensions, it should
+     usually be sufficient to return whatever was passed as the argument.
+
+  n. Assignments to references now need to ensure that they respect property
+     types that affect the reference. This means that references should no
+     longer be directly assigned to, and instead a set of specialized macros
+     of the form ZEND_TRY_ASSIGN* needs to be used. You can find detailed
+     porting instructions as well as a compatibility shim in the wiki:
+     https://wiki.php.net/rfc/typed_properties_v2#assignments_to_references
+
 ========================
 2. Build system changes
 ========================

diff --git a/Zend/tests/type_declarations/typed_properties_001.phpt b/Zend/tests/type_declarations/typed_properties_001.phpt
new file mode 100644 (file)
index 0000000..6e34cb4
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_001.phpt
@@ -0,0 +1,44 @@
+--TEST--
+Test typed properties basic operation
+--FILE--
+<?php
+var_dump(new class(1, 2.2, true, ["four"], new stdClass) {
+       public int $int;
+       public float $float;
+       public bool $bool;
+       public array $array;
+       public stdClass $std;
+       public iterable $it;
+
+       public function __construct(int $int, float $float, bool $bool, array $array, stdClass $std) {
+               $this->int = $int;
+               $this->float = $float;
+               $this->bool = $bool;
+               $this->array = $array;
+               $this->std = $std;
+               $this->it = $array;
+       }
+});
+?>
+--EXPECTF--
+object(class@anonymous)#%d (6) {
+  ["int"]=>
+  int(1)
+  ["float"]=>
+  float(2.2)
+  ["bool"]=>
+  bool(true)
+  ["array"]=>
+  array(1) {
+    [0]=>
+    string(4) "four"
+  }
+  ["std"]=>
+  object(stdClass)#%d (0) {
+  }
+  ["it"]=>
+  array(1) {
+    [0]=>
+    string(4) "four"
+  }
+}

diff --git a/Zend/tests/type_declarations/typed_properties_002.phpt b/Zend/tests/type_declarations/typed_properties_002.phpt
new file mode 100644 (file)
index 0000000..3aec7a3
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_002.phpt
@@ -0,0 +1,15 @@
+--TEST--
+Test typed properties error condition (read uninitialized)
+--FILE--
+<?php
+$thing = new class() {
+       public int $int;
+};
+
+var_dump($thing->int);
+?>
+--EXPECTF--
+Fatal error: Uncaught Error: Typed property class@anonymous::$int must not be accessed before initialization in %s:6
+Stack trace:
+#0 {main}
+  thrown in %s on line 6

diff --git a/Zend/tests/type_declarations/typed_properties_003.phpt b/Zend/tests/type_declarations/typed_properties_003.phpt
new file mode 100644 (file)
index 0000000..59c289a
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_003.phpt
@@ -0,0 +1,15 @@
+--TEST--
+Test typed properties error condition (fetch uninitialized by reference)
+--FILE--
+<?php
+$thing = new class() {
+       public int $int;
+};
+
+$var = &$thing->int;
+?>
+--EXPECTF--
+Fatal error: Uncaught Error: Cannot access uninitialized non-nullable property class@anonymous::$int by reference in %s:%d
+Stack trace:
+#0 {main}
+  thrown in %s on line %d

diff --git a/Zend/tests/type_declarations/typed_properties_004.phpt b/Zend/tests/type_declarations/typed_properties_004.phpt
new file mode 100644 (file)
index 0000000..03d9e41
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_004.phpt
@@ -0,0 +1,18 @@
+--TEST--
+Test typed properties error condition (type mismatch)
+--FILE--
+<?php
+new class("PHP 7 is better than you, and it knows it ...") {
+       public int $int;
+
+       public function __construct(string $string) {
+               $this->int = $string;
+       }
+};
+?>
+--EXPECTF--
+Fatal error: Uncaught TypeError: Typed property class@anonymous::$int must be int, string used in %s:6
+Stack trace:
+#0 %s(2): class@anonymous->__construct('PHP 7 is better...')
+#1 {main}
+  thrown in %s on line 6

diff --git a/Zend/tests/type_declarations/typed_properties_005.phpt b/Zend/tests/type_declarations/typed_properties_005.phpt
new file mode 100644 (file)
index 0000000..b521963
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_005.phpt
@@ -0,0 +1,20 @@
+--TEST--
+Test typed properties error condition (type mismatch object)
+--FILE--
+<?php
+class Dummy {}
+
+new class(new Dummy) {
+       public stdClass $std;
+
+       public function __construct(Dummy $dummy) {
+               $this->std = $dummy;
+       }
+};
+?>
+--EXPECTF--
+Fatal error: Uncaught TypeError: Typed property class@anonymous::$std must be an instance of stdClass, Dummy used in %s:8
+Stack trace:
+#0 %s(4): class@anonymous->__construct(Object(Dummy))
+#1 {main}
+  thrown in %s on line 8

diff --git a/Zend/tests/type_declarations/typed_properties_006.phpt b/Zend/tests/type_declarations/typed_properties_006.phpt
new file mode 100644 (file)
index 0000000..c3a8fae
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_006.phpt
@@ -0,0 +1,14 @@
+--TEST--
+Test typed properties inheritance (scalar)
+--FILE--
+<?php
+class Foo {
+       public int $qux;
+}
+
+class Bar extends Foo {
+       public string $qux;
+}
+?>
+--EXPECTF--
+Fatal error: Type of Bar::$qux must be int (as in class Foo) in %s on line 8

diff --git a/Zend/tests/type_declarations/typed_properties_007.phpt b/Zend/tests/type_declarations/typed_properties_007.phpt
new file mode 100644 (file)
index 0000000..19e8022
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_007.phpt
@@ -0,0 +1,17 @@
+--TEST--
+Test typed properties inheritance
+--FILE--
+<?php
+class Whatever {}
+class Thing extends Whatever {}
+
+class Foo {
+       public Whatever $qux;
+}
+
+class Bar extends Foo {
+       public Thing $qux;
+}
+?>
+--EXPECTF--
+Fatal error: Type of Bar::$qux must be Whatever (as in class Foo) in %s on line 11

diff --git a/Zend/tests/type_declarations/typed_properties_008.phpt b/Zend/tests/type_declarations/typed_properties_008.phpt
new file mode 100644 (file)
index 0000000..70b4282
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_008.phpt
@@ -0,0 +1,14 @@
+--TEST--
+Test typed properties inheritance (missing info)
+--FILE--
+<?php
+class Foo {
+       public int $qux;
+}
+
+class Bar extends Foo {
+       public $qux;
+}
+?>
+--EXPECTF--
+Fatal error: Type of Bar::$qux must be int (as in class Foo) in %s on line 8

diff --git a/Zend/tests/type_declarations/typed_properties_009.phpt b/Zend/tests/type_declarations/typed_properties_009.phpt
new file mode 100644 (file)
index 0000000..24013b4
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_009.phpt
@@ -0,0 +1,23 @@
+--TEST--
+Test typed properties unset leaves properties in an uninitialized state
+--FILE--
+<?php
+class Foo {
+       public int $bar;
+
+       public function __get($name) {
+               var_dump($name);
+               /* return value has to be compatible with int */
+               return 0;
+       }
+}
+
+$foo = new Foo();
+
+unset($foo->bar);
+
+var_dump($foo->bar);
+?>
+--EXPECT--
+string(3) "bar"
+int(0)

diff --git a/Zend/tests/type_declarations/typed_properties_010.phpt b/Zend/tests/type_declarations/typed_properties_010.phpt
new file mode 100644 (file)
index 0000000..fd7d367
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_010.phpt
@@ -0,0 +1,17 @@
+--TEST--
+Test typed properties allow fetch reference
+--FILE--
+<?php
+class Foo {
+       public int $bar = 1;
+}
+
+$cb = function(int &$bar) {
+       var_dump($bar);
+};
+
+$foo = new Foo();
+$cb($foo->bar);
+?>
+--EXPECT--
+int(1)

diff --git a/Zend/tests/type_declarations/typed_properties_011.phpt b/Zend/tests/type_declarations/typed_properties_011.phpt
new file mode 100644 (file)
index 0000000..706a332
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_011.phpt
@@ -0,0 +1,18 @@
+--TEST--
+Test typed properties allow fetch reference for init array
+--FILE--
+<?php
+class Foo {
+       public int $bar = 1;
+}
+
+$foo = new Foo();
+
+$array = [&$foo->bar];
+var_dump($array);
+?>
+--EXPECT--
+array(1) {
+  [0]=>
+  &int(1)
+}

diff --git a/Zend/tests/type_declarations/typed_properties_012.phpt b/Zend/tests/type_declarations/typed_properties_012.phpt
new file mode 100644 (file)
index 0000000..79a77cf
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_012.phpt
@@ -0,0 +1,19 @@
+--TEST--
+Test typed properties allow fetch reference for foreach
+--FILE--
+<?php
+class Foo {
+       public int $bar = 1;
+}
+
+$foo = new Foo();
+foreach ($foo as &$prop) {
+       $prop++;
+}
+var_dump($foo);
+?>
+--EXPECT--
+object(Foo)#1 (1) {
+  ["bar"]=>
+  &int(2)
+}

diff --git a/Zend/tests/type_declarations/typed_properties_013.phpt b/Zend/tests/type_declarations/typed_properties_013.phpt
new file mode 100644 (file)
index 0000000..01c2f4b
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_013.phpt
@@ -0,0 +1,10 @@
+--TEST--
+Test typed properties disallow incorrect type initial value (scalar)
+--FILE--
+<?php
+class Foo {
+       public int $bar = "string";
+}
+?>
+--EXPECTF--
+Fatal error: Default value for property of type int can only be int in %s on line 3

diff --git a/Zend/tests/type_declarations/typed_properties_014.phpt b/Zend/tests/type_declarations/typed_properties_014.phpt
new file mode 100644 (file)
index 0000000..2a02f03
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_014.phpt
@@ -0,0 +1,10 @@
+--TEST--
+Test typed properties disallow incorrect type initial value (array)
+--FILE--
+<?php
+class Foo {
+       public array $bar = 32;
+}
+?>
+--EXPECTF--
+Fatal error: Default value for property of type array can only be an array in %s on line 3

diff --git a/Zend/tests/type_declarations/typed_properties_015.phpt b/Zend/tests/type_declarations/typed_properties_015.phpt
new file mode 100644 (file)
index 0000000..ac11c0f
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_015.phpt
@@ -0,0 +1,10 @@
+--TEST--
+Test typed properties disallow incorrect type initial value (object)
+--FILE--
+<?php
+class Foo {
+       public stdClass $bar = null;
+}
+?>
+--EXPECTF--
+Fatal error: Default value for property of type stdClass may not be null. Use the nullable type ?stdClass to allow null default value in %s on line %d

diff --git a/Zend/tests/type_declarations/typed_properties_016.phpt b/Zend/tests/type_declarations/typed_properties_016.phpt
new file mode 100644 (file)
index 0000000..e2b98a0
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_016.phpt
@@ -0,0 +1,16 @@
+--TEST--
+Test typed properties initial values
+--FILE--
+<?php
+class Foo {
+       public int $int = 1;
+       public float $flt = 2.2;
+    public float $flt2 = 2;
+       public array $arr = [];
+       public bool $bool = false;
+    public iterable $iter = [];
+}
+echo "ok\n";
+?>
+--EXPECT--
+ok

diff --git a/Zend/tests/type_declarations/typed_properties_017.phpt b/Zend/tests/type_declarations/typed_properties_017.phpt
new file mode 100644 (file)
index 0000000..3e501d3
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_017.phpt
@@ -0,0 +1,12 @@
+--TEST--
+Test typed properties disallow void
+--FILE--
+<?php
+class Foo {
+       public void $int;
+}
+
+$foo = new Foo();
+?>
+--EXPECTF--
+Fatal error: Property Foo::$int cannot have type void in %s on line 3

diff --git a/Zend/tests/type_declarations/typed_properties_018.phpt b/Zend/tests/type_declarations/typed_properties_018.phpt
new file mode 100644 (file)
index 0000000..097b39b
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_018.phpt
@@ -0,0 +1,17 @@
+--TEST--
+Test typed properties type applies to all props in group
+--FILE--
+<?php
+class Foo {
+       public int $bar,
+                               $qux;
+}
+
+$reflector = new ReflectionClass(Foo::class);
+
+$prop = $reflector->getProperty("qux");
+
+var_dump((string) $prop->getType());
+?>
+--EXPECT--
+string(3) "int"

diff --git a/Zend/tests/type_declarations/typed_properties_019.phpt b/Zend/tests/type_declarations/typed_properties_019.phpt
new file mode 100644 (file)
index 0000000..d804b9c
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_019.phpt
@@ -0,0 +1,22 @@
+--TEST--
+Test typed properties int must not be allowed to overflow
+--FILE--
+<?php
+class Foo {
+    public int $bar = PHP_INT_MAX;
+
+    public function inc() {
+        return ++$this->bar;
+    }
+}
+
+$foo = new Foo();
+
+try {
+    $foo->inc();
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+?>
+--EXPECT--
+Cannot increment property Foo::$bar of type int past its maximal value

diff --git a/Zend/tests/type_declarations/typed_properties_020.phpt b/Zend/tests/type_declarations/typed_properties_020.phpt
new file mode 100644 (file)
index 0000000..d32d17b
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_020.phpt
@@ -0,0 +1,26 @@
+--TEST--
+Test typed properties binary assign op helper test
+--FILE--
+<?php
+declare(strict_types=1);
+
+class Foo {
+    public int $bar = 0;
+
+    public function __construct() {
+        $this->bar += 2;
+        try {
+            $this->bar += 1.5;
+        } catch (TypeError $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+}
+
+$foo = new Foo();
+
+var_dump($foo->bar);
+?>
+--EXPECT--
+Typed property Foo::$bar must be int, float used
+int(2)

diff --git a/Zend/tests/type_declarations/typed_properties_021.phpt b/Zend/tests/type_declarations/typed_properties_021.phpt
new file mode 100644 (file)
index 0000000..a9f8252
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_021.phpt
@@ -0,0 +1,15 @@
+--TEST--
+Test typed properties delay type check on constant
+--FILE--
+<?php
+class Foo {
+       public int $bar = BAR::BAZ;
+}
+
+$foo = new Foo();
+?>
+--EXPECTF--
+Fatal error: Uncaught Error: Class 'BAR' not found in %s:%d
+Stack trace:
+#0 {main}
+  thrown in %s on line %d

diff --git a/Zend/tests/type_declarations/typed_properties_022.phpt b/Zend/tests/type_declarations/typed_properties_022.phpt
new file mode 100644 (file)
index 0000000..7e94782
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_022.phpt
@@ -0,0 +1,15 @@
+--TEST--
+Test typed properties delay type check on ast
+--FILE--
+<?php
+class Foo {
+       public int $bar = BAR::BAZ * 2;
+}
+
+$foo = new Foo();
+?>
+--EXPECTF--
+Fatal error: Uncaught Error: Class 'BAR' not found in %s:%d
+Stack trace:
+#0 {main}
+  thrown in %s on line %d

diff --git a/Zend/tests/type_declarations/typed_properties_023.phpt b/Zend/tests/type_declarations/typed_properties_023.phpt
new file mode 100644 (file)
index 0000000..1531b23
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_023.phpt
@@ -0,0 +1,52 @@
+--TEST--
+Test typed static property
+--FILE--
+<?php
+function &ref() {
+       static $a = 5;
+       return $a;
+}
+
+class Foo {
+       public static int $i;
+       public static string $s = "x";
+}
+
+var_dump(Foo::$i = 1);
+var_dump(Foo::$i);
+var_dump(Foo::$i = "1");
+var_dump(Foo::$i);
+
+var_dump(Foo::$s);
+var_dump(Foo::$s = Foo::$i++);
+var_dump(Foo::$s, Foo::$i);
+$a = 3;
+var_dump(Foo::$s = $a);
+var_dump(Foo::$s);
+var_dump(Foo::$i = "4");
+var_dump(Foo::$i);
+
+var_dump(Foo::$i = ref());
+var_dump(Foo::$i);
+var_dump(Foo::$s = ref());
+var_dump(Foo::$s);
+var_dump(ref());
+?>
+--EXPECT--
+int(1)
+int(1)
+int(1)
+int(1)
+string(1) "x"
+string(1) "1"
+string(1) "1"
+int(2)
+string(1) "3"
+string(1) "3"
+int(4)
+int(4)
+int(5)
+int(5)
+string(1) "5"
+string(1) "5"
+int(5)

diff --git a/Zend/tests/type_declarations/typed_properties_024.phpt b/Zend/tests/type_declarations/typed_properties_024.phpt
new file mode 100644 (file)
index 0000000..96f7216
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_024.phpt
@@ -0,0 +1,16 @@
+--TEST--
+Test typed properties ignore private props during inheritance
+--FILE--
+<?php
+class Foo {
+       private int $thing;
+}
+
+class Bar extends Foo {
+    public string $thing; // No conflict
+}
+
+echo "ok";
+?>
+--EXPECT--
+ok

diff --git a/Zend/tests/type_declarations/typed_properties_025.phpt b/Zend/tests/type_declarations/typed_properties_025.phpt
new file mode 100644 (file)
index 0000000..65187c1
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_025.phpt
@@ -0,0 +1,11 @@
+--TEST--
+Test typed properties type must preceed first declaration in group
+--FILE--
+<?php
+class Foo {
+    public $bar,
+           int $qux;
+}
+?>
+--EXPECTF--
+Parse error: syntax error, unexpected 'int' (T_STRING), expecting variable (T_VARIABLE) in %s on line 4

diff --git a/Zend/tests/type_declarations/typed_properties_026.phpt b/Zend/tests/type_declarations/typed_properties_026.phpt
new file mode 100644 (file)
index 0000000..a2c4e25
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_026.phpt
@@ -0,0 +1,23 @@
+--TEST--
+Test typed properties inherit traits with typed properties
+--FILE--
+<?php
+trait Foo{
+    private int $baz;
+}
+
+class Baz{
+    use Foo;
+
+    function get(){
+        return $this->baz;
+    }
+}
+
+var_dump((new Baz)->get());
+--EXPECTF--
+Fatal error: Uncaught Error: Typed property Baz::$baz must not be accessed before initialization in %s:10
+Stack trace:
+#0 %s(14): Baz->get()
+#1 {main}
+  thrown in %s on line 10

diff --git a/Zend/tests/type_declarations/typed_properties_027.phpt b/Zend/tests/type_declarations/typed_properties_027.phpt
new file mode 100644 (file)
index 0000000..8617699
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_027.phpt
@@ -0,0 +1,16 @@
+--TEST--
+Test typed properties float widen at runtime
+--FILE--
+<?php
+
+class Foo {
+       public float $bar = 1.1;
+}
+
+$foo = new Foo;
+$foo->bar = 10;
+
+var_dump($foo->bar);
+?>
+--EXPECT--
+float(10)

diff --git a/Zend/tests/type_declarations/typed_properties_028.phpt b/Zend/tests/type_declarations/typed_properties_028.phpt
new file mode 100644 (file)
index 0000000..de1b3f6
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_028.phpt
@@ -0,0 +1,15 @@
+--TEST--
+Test typed properties respect strict types (off)
+--FILE--
+<?php
+class Foo {
+       public int $bar;
+}
+
+$foo = new Foo;
+$foo->bar = "1";
+
+var_dump($foo->bar);
+?>
+--EXPECT--
+int(1)

diff --git a/Zend/tests/type_declarations/typed_properties_029.phpt b/Zend/tests/type_declarations/typed_properties_029.phpt
new file mode 100644 (file)
index 0000000..a5418c9
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_029.phpt
@@ -0,0 +1,18 @@
+--TEST--
+Test typed properties respect strict types (on)
+--FILE--
+<?php
+declare(strict_types=1);
+
+class Foo {
+       public int $bar;
+}
+
+$foo = new Foo;
+$foo->bar = "1";
+?>
+--EXPECTF--
+Fatal error: Uncaught TypeError: Typed property Foo::$bar must be int, string used in %s:9
+Stack trace:
+#0 {main}
+  thrown in %s on line 9

diff --git a/Zend/tests/type_declarations/typed_properties_030.phpt b/Zend/tests/type_declarations/typed_properties_030.phpt
new file mode 100644 (file)
index 0000000..a835ae5
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_030.phpt
@@ -0,0 +1,25 @@
+--TEST--
+Test typed properties unset __get magical magic
+--FILE--
+<?php
+class Foo {
+       public int $bar;
+
+       public function __get($name) {
+               return "violate";
+       }
+}
+
+$foo = new Foo;
+
+$foo->bar = "1"; # ok
+
+unset($foo->bar); # ok
+
+var_dump($foo->bar); # not okay, __get is nasty
+?>
+--EXPECTF--
+Fatal error: Uncaught TypeError: Typed property Foo::$bar must be int, string used in %s:16
+Stack trace:
+#0 {main}
+  thrown in %s on line 16

diff --git a/Zend/tests/type_declarations/typed_properties_031.phpt b/Zend/tests/type_declarations/typed_properties_031.phpt
new file mode 100644 (file)
index 0000000..8022d2e
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_031.phpt
@@ -0,0 +1,22 @@
+--TEST--
+Test typed properties coerce int to float even in strict mode
+--FILE--
+<?php
+declare(strict_types=1);
+
+class Bar
+{
+    public float $bar;
+
+    public function setBar($value) {
+        $this->bar = $value;
+    }
+}
+
+$bar = new Bar();
+
+$bar->setBar(100);
+
+var_dump($bar->bar);
+--EXPECT--
+float(100)

diff --git a/Zend/tests/type_declarations/typed_properties_032.phpt b/Zend/tests/type_declarations/typed_properties_032.phpt
new file mode 100644 (file)
index 0000000..f3ceeb5
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_032.phpt
@@ -0,0 +1,15 @@
+--TEST--
+Test typed properties return by ref is allowed
+--FILE--
+<?php
+$foo = new class {
+       public int $bar = 15;
+
+       public function &method() {
+               return $this->bar;
+       }
+};
+
+var_dump($foo->method());
+--EXPECT--
+int(15)

diff --git a/Zend/tests/type_declarations/typed_properties_033.phpt b/Zend/tests/type_declarations/typed_properties_033.phpt
new file mode 100644 (file)
index 0000000..87e6aef
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_033.phpt
@@ -0,0 +1,38 @@
+--TEST--
+Test typed properties yield reference guard
+--FILE--
+<?php
+$foo = new class {
+       public int $foo = 1;
+       public int $bar = 3; 
+       public int $baz = 5;
+       public int $qux = PHP_INT_MAX;
+
+       public function &fetch() {
+               yield $this->foo;
+               yield $this->bar;
+               yield $this->baz;
+               yield $this->qux;
+       }
+};
+
+try {
+       foreach ($foo->fetch() as &$prop) {
+               $prop += 1;
+       }
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+
+var_dump($foo);
+?>
+--EXPECTF--
+Cannot assign float to reference held by property class@anonymous::$qux of type int
+object(class@anonymous)#1 (4) {
+  ["foo"]=>
+  int(2)
+  ["bar"]=>
+  int(4)
+  ["baz"]=>
+  int(6)
+  ["qux"]=>
+  &int(%d)
+}

diff --git a/Zend/tests/type_declarations/typed_properties_034.phpt b/Zend/tests/type_declarations/typed_properties_034.phpt
new file mode 100644 (file)
index 0000000..c3885af
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_034.phpt
@@ -0,0 +1,51 @@
+--TEST--
+Test typed properties passed to typed function
+--FILE--
+<?php
+$foo = new class {
+       public ?int $bar = 42;
+       public int $baz;
+
+       public function &getIterator() {
+               foreach (['1', &$this->bar] as &$item) {
+                       yield $item;
+               }
+       }
+};
+
+function foo(?int &$a) {
+       var_dump($a);
+       $a = null;
+}
+
+foo($foo->bar);
+
+try {
+       $foo->baz = &$foo->bar;
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+$foo->bar = 10;
+
+foreach ($foo->getIterator() as &$item) {
+       $foo->baz = &$item;
+       var_dump($foo->baz);
+}
+
+try {
+       foo($foo->bar);
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+
+var_dump($foo);
+?>
+--EXPECT--
+int(42)
+Typed property class@anonymous::$baz must be int, null used
+int(1)
+int(10)
+int(10)
+Cannot assign null to reference held by property class@anonymous::$baz of type int
+object(class@anonymous)#1 (2) {
+  ["bar"]=>
+  &int(10)
+  ["baz"]=>
+  &int(10)
+}

diff --git a/Zend/tests/type_declarations/typed_properties_035.phpt b/Zend/tests/type_declarations/typed_properties_035.phpt
new file mode 100644 (file)
index 0000000..923f7a2
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_035.phpt
@@ -0,0 +1,13 @@
+--TEST--
+Test typed properties inheritance must not change type
+--FILE--
+<?php
+class Foo{
+    public $bar = 42;
+}
+
+class Baz extends Foo{
+    public int $bar = 33;
+}
+--EXPECTF--
+Fatal error: Type of Baz::$bar must not be defined (as in class Foo) in %s on line 8

diff --git a/Zend/tests/type_declarations/typed_properties_036.phpt b/Zend/tests/type_declarations/typed_properties_036.phpt
new file mode 100644 (file)
index 0000000..edb87a3
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_036.phpt
@@ -0,0 +1,15 @@
+--TEST--
+Test unitialized typed properties normal foreach must not be yielded
+--FILE--
+<?php
+$foo = new class {
+       public int $bar = 10, $qux;
+};
+
+foreach ($foo as $key => $bar) {
+       var_dump($key, $bar);
+}
+?>
+--EXPECT--
+string(3) "bar"
+int(10)

diff --git a/Zend/tests/type_declarations/typed_properties_037.phpt b/Zend/tests/type_declarations/typed_properties_037.phpt
new file mode 100644 (file)
index 0000000..c5dde53
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_037.phpt
@@ -0,0 +1,16 @@
+--TEST--
+Test typed properties var_dump uninitialized
+--FILE--
+<?php
+$foo = new class {
+       public int $bar = 10, $qux;
+};
+
+var_dump($foo);
+--EXPECTF--
+object(class@anonymous)#%d (1) {
+  ["bar"]=>
+  int(10)
+  ["qux"]=>
+  uninitialized(int)
+}

diff --git a/Zend/tests/type_declarations/typed_properties_038.phpt b/Zend/tests/type_declarations/typed_properties_038.phpt
new file mode 100644 (file)
index 0000000..44e5d04
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_038.phpt
@@ -0,0 +1,61 @@
+--TEST--
+Test typed properties overflowing
+--FILE--
+<?php
+
+$foo = new class {
+       public int $bar = PHP_INT_MAX;
+};
+
+try {
+       $foo->bar++;
+} catch(TypeError $t) {
+       var_dump($t->getMessage());
+}
+
+var_dump($foo);
+
+try {
+       $foo->bar += 1;
+} catch(TypeError $t) {
+       var_dump($t->getMessage());
+}
+
+var_dump($foo);
+
+try {
+       ++$foo->bar;
+} catch(TypeError $t) {
+       var_dump($t->getMessage());
+}
+
+var_dump($foo);
+
+try {
+       $foo->bar = $foo->bar + 1;
+} catch(TypeError $t) {
+       var_dump($t->getMessage());
+}
+
+var_dump($foo);
+--EXPECTF--
+string(82) "Cannot increment property class@anonymous::$bar of type int past its maximal value"
+object(class@anonymous)#1 (1) {
+  ["bar"]=>
+  int(%d)
+}
+string(60) "Typed property class@anonymous::$bar must be int, float used"
+object(class@anonymous)#1 (1) {
+  ["bar"]=>
+  int(%d)
+}
+string(82) "Cannot increment property class@anonymous::$bar of type int past its maximal value"
+object(class@anonymous)#1 (1) {
+  ["bar"]=>
+  int(%d)
+}
+string(60) "Typed property class@anonymous::$bar must be int, float used"
+object(class@anonymous)#1 (1) {
+  ["bar"]=>
+  int(%d)
+}

diff --git a/Zend/tests/type_declarations/typed_properties_039.phpt b/Zend/tests/type_declarations/typed_properties_039.phpt
new file mode 100644 (file)
index 0000000..62413d8
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_039.phpt
@@ -0,0 +1,31 @@
+--TEST--
+Repeated assign of a variable to mismatched property type must not succeed
+--FILE--
+<?php
+
+class A {
+        public int $foo;
+}
+
+class B {
+        public A $foo;
+}
+
+$objs = [new A, new A];
+$v = 1;
+
+foreach ($objs as $obj) {
+        $obj->foo = $v;
+        $v = new A;
+        $obj = new B;
+        $obj->foo = $v;
+}
+
+var_dump($objs);
+
+?>
+--EXPECTF--
+Fatal error: Uncaught TypeError: Typed property A::$foo must be int, A used in %s:%d
+Stack trace:
+#0 {main}
+  thrown in %s on line %d

diff --git a/Zend/tests/type_declarations/typed_properties_040.phpt b/Zend/tests/type_declarations/typed_properties_040.phpt
new file mode 100644 (file)
index 0000000..db2b909
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_040.phpt
@@ -0,0 +1,25 @@
+--TEST--
+Test __get on unset typed property must fail properly
+--FILE--
+<?php
+declare(strict_types=1);
+
+class Foo {
+       public int $bar;
+
+       public function __get($name) {
+               var_dump($name);
+       }
+}
+
+$foo = new Foo();
+
+var_dump($foo->bar);
+?>
+--EXPECTF--
+string(3) "bar"
+
+Fatal error: Uncaught TypeError: Typed property Foo::$bar must be int, null used in %s:14
+Stack trace:
+#0 {main}
+  thrown in %s on line 14

diff --git a/Zend/tests/type_declarations/typed_properties_041.phpt b/Zend/tests/type_declarations/typed_properties_041.phpt
new file mode 100644 (file)
index 0000000..76dbfd8
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_041.phpt
@@ -0,0 +1,16 @@
+--TEST--
+Test typed properties weak conversion of strings
+--FILE--
+<?php
+
+class Foo {
+       public int $bar = 1;
+}
+
+$foo = new Foo;
+$foo->bar = "10";
+
+var_dump($foo->bar);
+?>
+--EXPECT--
+int(10)

diff --git a/Zend/tests/type_declarations/typed_properties_042.phpt b/Zend/tests/type_declarations/typed_properties_042.phpt
new file mode 100644 (file)
index 0000000..ecb3df3
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_042.phpt
@@ -0,0 +1,21 @@
+--TEST--
+Proper source duplication on assignment to typed property
+--FILE--
+<?php
+class Foo {
+       public int $bar;
+}
+
+$foo = new Foo();
+
+for ($i = 0; $i < 5; $i++) {
+       $foo->bar = "5";
+       var_dump($foo->bar);
+}
+?>
+--EXPECT--
+int(5)
+int(5)
+int(5)
+int(5)
+int(5)

diff --git a/Zend/tests/type_declarations/typed_properties_043.phpt b/Zend/tests/type_declarations/typed_properties_043.phpt
new file mode 100644 (file)
index 0000000..eefe358
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_043.phpt
@@ -0,0 +1,53 @@
+--TEST--
+Trying to assign to a static 'self' typed property on a trait must not fixate the type to the trait
+--FILE--
+<?php
+
+trait Test {
+    public static self $selfProp;
+    public static ?self $selfNullProp;
+    public static parent $parentProp;
+}
+
+try {
+    Test::$selfProp = new stdClass;
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    Test::$selfNullProp = new stdClass;
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    Test::$parentProp = new stdClass;
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+
+Test::$selfNullProp = null;
+var_dump(Test::$selfNullProp);
+
+class Foo {}
+class Bar extends Foo {
+    use Test;
+}
+
+Bar::$selfProp = new Bar;
+Bar::$selfNullProp = new Bar;
+Bar::$parentProp = new Foo;
+
+var_dump(Bar::$selfProp, Bar::$selfNullProp, Bar::$parentProp);
+
+?>
+--EXPECT--
+Cannot write a value to a 'self' typed static property of a trait
+Cannot write a non-null value to a 'self' typed static property of a trait
+Cannot access parent:: when current class scope has no parent
+NULL
+object(Bar)#3 (0) {
+}
+object(Bar)#2 (0) {
+}
+object(Foo)#4 (0) {
+}

diff --git a/Zend/tests/type_declarations/typed_properties_044.phpt b/Zend/tests/type_declarations/typed_properties_044.phpt
new file mode 100644 (file)
index 0000000..02a71a7
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_044.phpt
@@ -0,0 +1,58 @@
+--TEST--
+Test increment functions on typed property references
+--SKIPIF--
+<?php if (PHP_INT_SIZE != 8) die("skip this test is for 64 bit platform only"); ?>
+--FILE--
+<?php
+$foo = new class {
+       public ?int $bar;
+};
+
+$bar = &$foo->bar;
+
+$bar *= 1;
+
+var_dump($bar--);
+var_dump(--$bar);
+var_dump(++$bar);
+var_dump($bar++);
+
+$bar = PHP_INT_MAX;
+
+try {
+       var_dump($bar++);
+} catch (Throwable $e) {
+       echo $e->getMessage() . "\n";
+}
+
+try {
+       var_dump(++$bar);
+} catch (Throwable $e) {
+       echo $e->getMessage() . "\n";
+}
+
+$bar = PHP_INT_MIN;
+
+
+try {
+       var_dump($bar--);
+} catch (Throwable $e) {
+       echo $e->getMessage() . "\n";
+}
+
+try {
+       var_dump(--$bar);
+} catch (Throwable $e) {
+       echo $e->getMessage() . "\n";
+}
+
+?>
+--EXPECT--
+int(0)
+int(-2)
+int(-1)
+int(-1)
+Cannot increment a reference held by property class@anonymous::$bar of type ?int past its maximal value
+Cannot increment a reference held by property class@anonymous::$bar of type ?int past its maximal value
+Cannot decrement a reference held by property class@anonymous::$bar of type ?int past its minimal value
+Cannot decrement a reference held by property class@anonymous::$bar of type ?int past its minimal value

diff --git a/Zend/tests/type_declarations/typed_properties_045.phpt b/Zend/tests/type_declarations/typed_properties_045.phpt
new file mode 100644 (file)
index 0000000..7e4dc8e
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_045.phpt
@@ -0,0 +1,51 @@
+--TEST--
+foreach() must return properly typed references
+--FILE--
+<?php
+class Foo {
+    public int $bar = 0;
+    public float $baz = 0.5;
+    private float $privateProp = 0.5;
+
+    public function test() {
+        foreach ($this as $k => &$val) {
+            if ($k == 'privateProp') {
+                var_dump($val);
+                $val = 20;
+                var_dump($val);
+                try {
+                    $val = [];
+                } catch (Error $e) {
+                    echo $e->getMessage(), "\n";
+                }
+            }
+        }
+    }
+}
+
+$foo = new Foo;
+foreach ($foo as $k => &$val) {
+    var_dump($val);
+
+    $val = 20;
+    var_dump($foo->$k);
+
+    try {
+        $val = [];
+        var_dump($foo->$k);
+    } catch (Error $e) {
+        echo $e->getMessage(), "\n";
+    }
+}
+$foo->test();
+?>
+--EXPECT--
+int(0)
+int(20)
+Cannot assign array to reference held by property Foo::$bar of type int
+float(0.5)
+float(20)
+Cannot assign array to reference held by property Foo::$baz of type float
+float(0.5)
+float(20)
+Cannot assign array to reference held by property Foo::$privateProp of type float

diff --git a/Zend/tests/type_declarations/typed_properties_046.phpt b/Zend/tests/type_declarations/typed_properties_046.phpt
new file mode 100644 (file)
index 0000000..050e64a
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_046.phpt
@@ -0,0 +1,29 @@
+--TEST--
+Memory leaks on wrong assignment to typed property
+--FILE--
+<?php
+class Foo {
+       public int $bbb;
+}
+
+function foo() {
+       return new Foo();
+}
+
+function bar() {
+       return str_repeat("b", 3);
+}
+
+for ($i = 0; $i < 5; $i++) {
+       try {
+               foo()->{bar()} = str_repeat("a", 3);
+       } catch (Throwable $e) {
+               echo $e->getMessage() . "\n";
+       }
+}
+--EXPECT--
+Typed property Foo::$bbb must be int, string used
+Typed property Foo::$bbb must be int, string used
+Typed property Foo::$bbb must be int, string used
+Typed property Foo::$bbb must be int, string used
+Typed property Foo::$bbb must be int, string used

diff --git a/Zend/tests/type_declarations/typed_properties_047.phpt b/Zend/tests/type_declarations/typed_properties_047.phpt
new file mode 100644 (file)
index 0000000..7f1e573
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_047.phpt
@@ -0,0 +1,40 @@
+--TEST--
+Nullable typed property
+--FILE--
+<?php
+class Foo {
+       public ?int $foo = null;
+}
+
+$x = new Foo();
+var_dump($x);
+var_dump($x->foo);
+
+$x->foo = 5;
+var_dump($x->foo);
+
+$x->foo = null;
+var_dump($x->foo);
+
+unset($x->foo);
+try {
+       var_dump($x->foo);
+} catch (Throwable $e) {
+       echo $e->getMessage()."\n";
+}
+try {
+       $x->foo = "ops";
+} catch (Throwable $e) {
+       echo $e->getMessage()."\n";
+}
+?>
+--EXPECTF--
+object(Foo)#1 (1) {
+  ["foo"]=>
+  NULL
+}
+NULL
+int(5)
+NULL
+Typed property Foo::$foo must not be accessed before initialization
+Typed property Foo::$foo must be int or null, string used

diff --git a/Zend/tests/type_declarations/typed_properties_048.phpt b/Zend/tests/type_declarations/typed_properties_048.phpt
new file mode 100644 (file)
index 0000000..8a06c55
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_048.phpt
@@ -0,0 +1,17 @@
+--TEST--
+Parent private property types must be ignored
+--FILE--
+<?php
+
+class A {
+       private $prop = "1";
+}
+class B extends A {
+       private int $prop = 2;
+}
+
+var_dump((function () { return $this->prop; })->call(new B));
+
+?>
+--EXPECT--
+int(2)

diff --git a/Zend/tests/type_declarations/typed_properties_049.phpt b/Zend/tests/type_declarations/typed_properties_049.phpt
new file mode 100644 (file)
index 0000000..e761590
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_049.phpt
@@ -0,0 +1,10 @@
+--TEST--
+Nullable typed property
+--FILE--
+<?php
+class Foo {
+       public int $foo = null;
+}
+?>
+--EXPECTF--
+Fatal error: Default value for property of type int may not be null. Use the nullable type ?int to allow null default value in %s on line %d

diff --git a/Zend/tests/type_declarations/typed_properties_050.phpt b/Zend/tests/type_declarations/typed_properties_050.phpt
new file mode 100644 (file)
index 0000000..3fa8260
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_050.phpt
@@ -0,0 +1,19 @@
+--TEST--
+Weak casts must not overwrite source variables
+--FILE--
+<?php
+
+$b = 1;
+$a = "$b";
+class A { public int $a; }
+$o = new A;
+$o->a = $b;
+var_dump($o, $a);
+
+?>
+--EXPECT--
+object(A)#1 (1) {
+  ["a"]=>
+  int(1)
+}
+string(1) "1"

diff --git a/Zend/tests/type_declarations/typed_properties_051.phpt b/Zend/tests/type_declarations/typed_properties_051.phpt
new file mode 100644 (file)
index 0000000..1c8673d
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_051.phpt
@@ -0,0 +1,27 @@
+--TEST--
+Weak casts must not leak
+--FILE--
+<?php
+
+class A {
+       public string $a;
+}
+class B {
+       function __toString() {
+               return str_repeat("ok", 2);
+       }
+}
+class C {
+}
+$o = new A;
+$o->a = new B;
+var_dump($o->a);
+try {
+       $o->a = new C;
+} catch (Throwable $e) {
+       echo $e->getMessage()."\n";
+}
+?>
+--EXPECT--
+string(4) "okok"
+Typed property A::$a must be string, C used

diff --git a/Zend/tests/type_declarations/typed_properties_052.phpt b/Zend/tests/type_declarations/typed_properties_052.phpt
new file mode 100644 (file)
index 0000000..3a73d73
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_052.phpt
@@ -0,0 +1,34 @@
+--TEST--
+Class properties declared in eval() must not leak
+--FILE--
+<?php
+
+eval(<<<'EOF'
+class A {
+       public A      $a1;
+       public \B     $b1;
+       public Foo\C  $c1;
+       public ?A     $a2;
+       public ?\B    $b2;
+       public ?Foo\C $c2;
+}
+EOF
+);
+$obj = new A;
+var_dump($obj);
+?>
+--EXPECT--
+object(A)#1 (0) {
+  ["a1"]=>
+  uninitialized(A)
+  ["b1"]=>
+  uninitialized(B)
+  ["c1"]=>
+  uninitialized(Foo\C)
+  ["a2"]=>
+  uninitialized(?A)
+  ["b2"]=>
+  uninitialized(?B)
+  ["c2"]=>
+  uninitialized(?Foo\C)
+}

diff --git a/Zend/tests/type_declarations/typed_properties_053.phpt b/Zend/tests/type_declarations/typed_properties_053.phpt
new file mode 100644 (file)
index 0000000..1da42bc
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_053.phpt
@@ -0,0 +1,12 @@
+--TEST--
+Typed properties disallow callable
+--FILE--
+<?php
+class A {
+       public callable $a;
+}
+$obj = new A;
+var_dump($obj);
+?>
+--EXPECTF--
+Fatal error: Property A::$a cannot have type callable in %s on line %d

diff --git a/Zend/tests/type_declarations/typed_properties_054.phpt b/Zend/tests/type_declarations/typed_properties_054.phpt
new file mode 100644 (file)
index 0000000..38de981
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_054.phpt
@@ -0,0 +1,12 @@
+--TEST--
+Typed properties disallow callable (nullable variant)
+--FILE--
+<?php
+class A {
+       public ?callable $a;
+}
+$obj = new A;
+var_dump($obj);
+?>
+--EXPECTF--
+Fatal error: Property A::$a cannot have type callable in %s on line %d

diff --git a/Zend/tests/type_declarations/typed_properties_055.phpt b/Zend/tests/type_declarations/typed_properties_055.phpt
new file mode 100644 (file)
index 0000000..31d6872
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_055.phpt
@@ -0,0 +1,29 @@
+--TEST--
+Test assign to typed property taken by reference
+--FILE--
+<?php
+class A {
+       public $foo = 1;
+       public int $bar = 2;
+}
+class B {
+       public A $a;
+}
+$f = function (&$n) {
+       var_dump($n);
+       $n = "ops";
+};
+$o = new B;
+$o->a = new A;
+$f($o->a->foo);
+$f($o->a->bar);
+?>
+--EXPECTF--
+int(1)
+int(2)
+
+Fatal error: Uncaught TypeError: Cannot assign string to reference held by property A::$bar of type int in %s:%d
+Stack trace:
+#0 %s(%d): {closure}(2)
+#1 {main}
+  thrown in %s on line %d

diff --git a/Zend/tests/type_declarations/typed_properties_056.phpt b/Zend/tests/type_declarations/typed_properties_056.phpt
new file mode 100644 (file)
index 0000000..54013f4
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_056.phpt
@@ -0,0 +1,23 @@
+--TEST--
+Type change in assign_op (use-after-free)
+--FILE--
+<?php
+declare(strict_types=1);
+
+class A {
+       public string $foo;
+}
+
+$o = new A;
+$o->foo = "1" . str_repeat("0", 2);
+try {
+       $o->foo += 5;
+} catch (Throwable $e) {
+       echo $e->getMessage() . "\n";
+}
+var_dump($o->foo);
+unset($o);
+?>
+--EXPECT--
+Typed property A::$foo must be string, int used
+string(3) "100"

diff --git a/Zend/tests/type_declarations/typed_properties_057.phpt b/Zend/tests/type_declarations/typed_properties_057.phpt
new file mode 100644 (file)
index 0000000..6b53a42
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_057.phpt
@@ -0,0 +1,31 @@
+--TEST--
+Type change in pre/post-increment (use-after-free)
+--FILE--
+<?php
+declare(strict_types=1);
+
+class A {
+       public string $foo;
+}
+
+$o = new A;
+$o->foo = "1" . str_repeat("0", 2);
+try {
+       $x = ++$o->foo;
+} catch (Throwable $e) {
+       echo $e->getMessage() . "\n";
+}
+var_dump($o->foo);
+try {
+        $x = $o->foo++;
+} catch (Throwable $e) {
+        echo $e->getMessage() . "\n";
+}
+var_dump($o->foo);
+unset($o);
+?>
+--EXPECT--
+Typed property A::$foo must be string, int used
+string(3) "100"
+Typed property A::$foo must be string, int used
+string(3) "100"

diff --git a/Zend/tests/type_declarations/typed_properties_058.phpt b/Zend/tests/type_declarations/typed_properties_058.phpt
new file mode 100644 (file)
index 0000000..d9283bd
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_058.phpt
@@ -0,0 +1,32 @@
+--TEST--
+Constants in default values of properties
+--FILE--
+<?php
+declare(strict_types=1);
+
+define("FOO", 5);
+
+class A {
+       public int $foo = FOO;
+}
+
+class B {
+       public string $foo = FOO;
+}
+
+$o = new A();
+var_dump($o->foo);
+
+for ($i = 0; $i < 2; $i++) {
+       try {
+               $o = new B();
+               var_dump($o->foo);
+       } catch (Throwable $e) {
+               echo $e->getMessage() . "\n";
+       }
+}
+?>
+--EXPECT--
+int(5)
+Typed property B::$foo must be string, int used
+Typed property B::$foo must be string, int used

diff --git a/Zend/tests/type_declarations/typed_properties_059.phpt b/Zend/tests/type_declarations/typed_properties_059.phpt
new file mode 100644 (file)
index 0000000..caee850
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_059.phpt
@@ -0,0 +1,29 @@
+--TEST--
+Nullable typed properties in traits
+--FILE--
+<?php
+trait T {
+       public int $a1;
+       public ?int $b1;
+}
+
+class A {
+       use T;
+       public int $a2;
+       public ?int $b2;
+}
+
+$x = new A;
+var_dump($x);
+?>
+--EXPECT--
+object(A)#1 (0) {
+  ["a2"]=>
+  uninitialized(int)
+  ["b2"]=>
+  uninitialized(?int)
+  ["a1"]=>
+  uninitialized(int)
+  ["b1"]=>
+  uninitialized(?int)
+}

diff --git a/Zend/tests/type_declarations/typed_properties_060.phpt b/Zend/tests/type_declarations/typed_properties_060.phpt
new file mode 100644 (file)
index 0000000..559349b
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_060.phpt
@@ -0,0 +1,22 @@
+--TEST--
+Test typed properties work fine with simple inheritance
+--FILE--
+<?php
+
+class A {
+       public int $a = 1;
+}
+class B extends A {}
+
+$o = new B;
+var_dump($o->a);
+$o->a = "a";
+
+?>
+--EXPECTF--
+int(1)
+
+Fatal error: Uncaught TypeError: Typed property A::$a must be int, string used in %s:%d
+Stack trace:
+#0 {main}
+  thrown in %s on line %d

diff --git a/Zend/tests/type_declarations/typed_properties_061.phpt b/Zend/tests/type_declarations/typed_properties_061.phpt
new file mode 100644 (file)
index 0000000..647543c
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_061.phpt
@@ -0,0 +1,58 @@
+--TEST--
+Typed property on overloaded by-ref property
+--SKIPIF--
+<?php if (PHP_INT_SIZE == 4) die("SKIP: 64 bit test"); ?>
+--FILE--
+<?php
+
+$a = new class {
+       public int $foo = 1;
+
+       function &__get($x) {
+               return $this->foo;
+       }
+
+       function __set($x, $y) {
+               echo "set($y)\n";
+       }
+};
+
+$a->_ += 1;
+var_dump($a->foo);
+
+$a->_ .= "1";
+var_dump($a->foo);
+
+$a->_ .= "e50";
+var_dump($a->foo);
+
+$a->_--;
+var_dump($a->foo);
+
+--$a->_;
+var_dump($a->foo);
+
+$a->foo = PHP_INT_MAX;
+
+$a->_++;
+var_dump($a->foo);
+
+++$a->_;
+var_dump($a->foo);
+
+?>
+--EXPECT--
+set(2)
+int(1)
+set(11)
+int(1)
+set(1e50)
+int(1)
+set(0)
+int(1)
+set(0)
+int(1)
+set(9.2233720368548E+18)
+int(9223372036854775807)
+set(9.2233720368548E+18)
+int(9223372036854775807)

diff --git a/Zend/tests/type_declarations/typed_properties_062.phpt b/Zend/tests/type_declarations/typed_properties_062.phpt
new file mode 100644 (file)
index 0000000..45f4682
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_062.phpt
@@ -0,0 +1,81 @@
+--TEST--
+Typed property on by-ref property
+--FILE--
+<?php
+
+$a = new class {
+       public int $foo = 1;
+       public $_;
+};
+
+$a->_ = &$a->foo;
+
+$a->_ += 1;
+var_dump($a->foo);
+
+$a->_ .= "1";
+var_dump($a->foo);
+
+try {
+       $a->_ .= "e50";
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+var_dump($a->foo);
+
+$a->_--;
+var_dump($a->foo);
+
+--$a->_;
+var_dump($a->foo);
+
+$a->foo = PHP_INT_MIN;
+
+try {
+       $a->_--;
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+echo gettype($a->foo),"\n";
+
+try {
+       --$a->_;
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+echo gettype($a->foo),"\n";
+
+$a->foo = PHP_INT_MAX;
+
+try {
+       $a->_++;
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+echo gettype($a->foo),"\n";
+
+try {
+       ++$a->_;
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+echo gettype($a->foo),"\n";
+
+$a->_ = 0;
+try {
+       $a->_ = [];
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+var_dump($a->foo);
+
+$a->_ = 1;
+var_dump($a->foo);
+
+?>
+--EXPECT--
+int(2)
+int(21)
+Cannot assign string to reference held by property class@anonymous::$foo of type int
+int(21)
+int(20)
+int(19)
+Cannot decrement a reference held by property class@anonymous::$foo of type int past its minimal value
+integer
+Cannot decrement a reference held by property class@anonymous::$foo of type int past its minimal value
+integer
+Cannot increment a reference held by property class@anonymous::$foo of type int past its maximal value
+integer
+Cannot increment a reference held by property class@anonymous::$foo of type int past its maximal value
+integer
+Cannot assign array to reference held by property class@anonymous::$foo of type int
+int(0)
+int(1)

diff --git a/Zend/tests/type_declarations/typed_properties_063.phpt b/Zend/tests/type_declarations/typed_properties_063.phpt
new file mode 100644 (file)
index 0000000..bd4cccf
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_063.phpt
@@ -0,0 +1,80 @@
+--TEST--
+Typed property on by-ref variable
+--FILE--
+<?php
+
+$a = new class {
+       public int $foo = 1;
+};
+
+$_ = &$a->foo;
+
+$_ += 1;
+var_dump($a->foo);
+
+$_ .= "1";
+var_dump($a->foo);
+
+try {
+       $_ .= "e50";
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+var_dump($a->foo);
+
+$_--;
+var_dump($a->foo);
+
+--$_;
+var_dump($a->foo);
+
+$a->foo = PHP_INT_MIN;
+
+try {
+       $_--;
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+echo gettype($a->foo),"\n";
+
+try {
+       --$_;
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+echo gettype($a->foo),"\n";
+
+$a->foo = PHP_INT_MAX;
+
+try {
+       $_++;
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+echo gettype($a->foo),"\n";
+
+try {
+       ++$_;
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+echo gettype($a->foo),"\n";
+
+$_ = 0;
+try {
+       $_ = [];
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+var_dump($a->foo);
+
+$_ = 1;
+var_dump($a->foo);
+
+?>
+--EXPECT--
+int(2)
+int(21)
+Cannot assign string to reference held by property class@anonymous::$foo of type int
+int(21)
+int(20)
+int(19)
+Cannot decrement a reference held by property class@anonymous::$foo of type int past its minimal value
+integer
+Cannot decrement a reference held by property class@anonymous::$foo of type int past its minimal value
+integer
+Cannot increment a reference held by property class@anonymous::$foo of type int past its maximal value
+integer
+Cannot increment a reference held by property class@anonymous::$foo of type int past its maximal value
+integer
+Cannot assign array to reference held by property class@anonymous::$foo of type int
+int(0)
+int(1)

diff --git a/Zend/tests/type_declarations/typed_properties_064.phpt b/Zend/tests/type_declarations/typed_properties_064.phpt
new file mode 100644 (file)
index 0000000..59e0552
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_064.phpt
@@ -0,0 +1,80 @@
+--TEST--
+Typed property on by-ref array value
+--FILE--
+<?php
+
+$a = new class {
+       public int $foo = 1;
+};
+
+$_ = [&$a->foo];
+
+$_[0] += 1;
+var_dump($a->foo);
+
+$_[0] .= "1";
+var_dump($a->foo);
+
+try {
+       $_[0] .= "e50";
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+var_dump($a->foo);
+
+$_[0]--;
+var_dump($a->foo);
+
+--$_[0];
+var_dump($a->foo);
+
+$a->foo = PHP_INT_MIN;
+
+try {
+        $_[0]--;
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+echo gettype($a->foo),"\n";
+
+try {
+       --$_[0];
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+echo gettype($a->foo),"\n";
+
+$a->foo = PHP_INT_MAX;
+
+try {
+       $_[0]++;
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+echo gettype($a->foo),"\n";
+
+try {
+       ++$_[0];
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+echo gettype($a->foo),"\n";
+
+$_[0] = 0;
+try {
+       $_[0] = [];
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+var_dump($a->foo);
+
+$_[0] = 1;
+var_dump($a->foo);
+
+?>
+--EXPECT--
+int(2)
+int(21)
+Cannot assign string to reference held by property class@anonymous::$foo of type int
+int(21)
+int(20)
+int(19)
+Cannot decrement a reference held by property class@anonymous::$foo of type int past its minimal value
+integer
+Cannot decrement a reference held by property class@anonymous::$foo of type int past its minimal value
+integer
+Cannot increment a reference held by property class@anonymous::$foo of type int past its maximal value
+integer
+Cannot increment a reference held by property class@anonymous::$foo of type int past its maximal value
+integer
+Cannot assign array to reference held by property class@anonymous::$foo of type int
+int(0)
+int(1)

diff --git a/Zend/tests/type_declarations/typed_properties_065.phpt b/Zend/tests/type_declarations/typed_properties_065.phpt
new file mode 100644 (file)
index 0000000..da88cbf
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_065.phpt
@@ -0,0 +1,71 @@
+--TEST--
+Typed property on by-ref array dimension
+--FILE--
+<?php
+
+$a = new class implements ArrayAccess {
+       public int $foo = 1;
+
+       function offsetExists($o) { return 1; }
+       function &offsetGet($o) { return $this->foo; }
+       function offsetSet($o, $v) { print "offsetSet($v)\n"; }
+       function offsetUnset($o) { print "offsetUnset() ?!?"; }
+};
+
+$a[0] += 1;
+var_dump($a->foo);
+
+$a[0] .= "1";
+var_dump($a->foo);
+
+$a[0] .= "e50";
+var_dump($a->foo);
+
+$a[0]--;
+var_dump($a->foo);
+
+--$a[0];
+var_dump($a->foo);
+
+$a->foo = PHP_INT_MIN;
+
+try {
+        $a[0]--;
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+echo gettype($a->foo),"\n";
+
+try {
+       --$a[0];
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+echo gettype($a->foo),"\n";
+
+$a->foo = PHP_INT_MAX;
+
+try {
+       $a[0]++;
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+echo gettype($a->foo),"\n";
+
+try {
+       ++$a[0];
+} catch (Error $e) { echo $e->getMessage(), "\n"; }
+echo gettype($a->foo),"\n";
+
+?>
+--EXPECT--
+offsetSet(2)
+int(1)
+offsetSet(11)
+int(1)
+offsetSet(1e50)
+int(1)
+int(0)
+int(-1)
+Cannot decrement a reference held by property class@anonymous::$foo of type int past its minimal value
+integer
+Cannot decrement a reference held by property class@anonymous::$foo of type int past its minimal value
+integer
+Cannot increment a reference held by property class@anonymous::$foo of type int past its maximal value
+integer
+Cannot increment a reference held by property class@anonymous::$foo of type int past its maximal value
+integer

diff --git a/Zend/tests/type_declarations/typed_properties_066.phpt b/Zend/tests/type_declarations/typed_properties_066.phpt
new file mode 100644 (file)
index 0000000..a91a00d
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_066.phpt
@@ -0,0 +1,21 @@
+--TEST--
+Typed property assignment must not overwrite constants
+--FILE--
+<?php
+
+class Foo {
+       public float $x = 0.0;
+};
+
+$x = new Foo;
+$y =& $x->x;
+$y = 4;
+var_dump($x, 4); /* Optimizer will merge both "4" constants, making it immediately visible */
+
+?>
+--EXPECT--
+object(Foo)#1 (1) {
+  ["x"]=>
+  &float(4)
+}
+int(4)

diff --git a/Zend/tests/type_declarations/typed_properties_067.phpt b/Zend/tests/type_declarations/typed_properties_067.phpt
new file mode 100644 (file)
index 0000000..da6865e
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_067.phpt
@@ -0,0 +1,36 @@
+--TEST--
+Iterable typed properties must be accepted to by-ref array arguments
+--FILE--
+<?php
+
+$obj = new class {
+       public ?iterable $it = null;
+};
+
+function arr(?array &$arr) {
+       $arr = [1];
+}
+
+arr($obj->it);
+var_dump($obj->it);
+array_shift($obj->it);
+var_dump($obj->it);
+parse_str("foo=bar", $obj->it);
+var_dump($obj->it);
+$obj->it = [];
+var_dump($obj->it);
+
+?>
+--EXPECT--
+array(1) {
+  [0]=>
+  int(1)
+}
+array(0) {
+}
+array(1) {
+  ["foo"]=>
+  string(3) "bar"
+}
+array(0) {
+}

diff --git a/Zend/tests/type_declarations/typed_properties_068.phpt b/Zend/tests/type_declarations/typed_properties_068.phpt
new file mode 100644 (file)
index 0000000..7ed58d2
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_068.phpt
@@ -0,0 +1,87 @@
+--TEST--
+Test typed static property by ref
+--FILE--
+<?php
+function &ref($a = null) {
+       static $f;
+       if ($a !== null) $f = function &() use (&$a) { return $a; };
+       return $f();
+}
+
+class Foo {
+       public static int $i;
+       public static string $s = "x";
+}
+
+Foo::$i = &ref(5);
+var_dump(Foo::$i);
+
+$i = &Foo::$i;
+$i = 2;
+var_dump($i, Foo::$i);
+
+$i = "3";
+var_dump($i, Foo::$i);
+
+Foo::$i = "4";
+var_dump($i, Foo::$i);
+
+try {
+       $i = null;
+} catch (TypeError $e) { print $e->getMessage()."\n"; }
+var_dump($i, Foo::$i);
+
+try {
+       Foo::$i = null;
+} catch (TypeError $e) { print $e->getMessage()."\n"; }
+var_dump($i, Foo::$i);
+
+Foo::$s = &ref(5);
+var_dump(Foo::$s, ref());
+
+Foo::$i = &ref("0");
+var_dump(Foo::$i, ref());
+
+try {
+       Foo::$i = &ref("x");
+} catch (TypeError $e) { print $e->getMessage()."\n"; }
+var_dump(Foo::$i, ref());
+
+try {
+       Foo::$i = &Foo::$s;
+} catch (TypeError $e) { print $e->getMessage()."\n"; }
+var_dump(Foo::$i, Foo::$s);
+
+try {
+       Foo::$s = &Foo::$i;
+} catch (TypeError $e) { print $e->getMessage()."\n"; }
+var_dump(Foo::$i, Foo::$s);
+
+?>
+--EXPECT--
+int(5)
+int(2)
+int(2)
+int(3)
+int(3)
+int(4)
+int(4)
+Cannot assign null to reference held by property Foo::$i of type int
+int(4)
+int(4)
+Typed property Foo::$i must be int, null used
+int(4)
+int(4)
+string(1) "5"
+string(1) "5"
+int(0)
+int(0)
+Typed property Foo::$i must be int, string used
+int(0)
+string(1) "x"
+Reference with value of type string held by property Foo::$s of type string is not compatible with property Foo::$i of type int
+int(0)
+string(1) "5"
+Reference with value of type int held by property Foo::$i of type int is not compatible with property Foo::$s of type string
+int(0)
+string(1) "5"

diff --git a/Zend/tests/type_declarations/typed_properties_069.phpt b/Zend/tests/type_declarations/typed_properties_069.phpt
new file mode 100644 (file)
index 0000000..77cfc02
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_069.phpt
@@ -0,0 +1,27 @@
+--TEST--
+Test assign of invalid string to typed static int property
+--FILE--
+<?php
+
+function &nonNumericStringRef() {
+       static $a = "x";
+       return $a;
+}
+
+class Foo {
+       public static int $i;
+}
+
+try {
+       Foo::$i = &nonNumericStringRef();
+} catch (TypeError $e) { print $e->getMessage()."\n"; }
+try {
+       var_dump(Foo::$i);
+} catch (Error $e) { print $e->getMessage()."\n"; }
+var_dump(nonNumericStringRef());
+
+?>
+--EXPECT--
+Typed property Foo::$i must be int, string used
+Typed static property Foo::$i must not be accessed before initialization
+string(1) "x"

diff --git a/Zend/tests/type_declarations/typed_properties_070.phpt b/Zend/tests/type_declarations/typed_properties_070.phpt
new file mode 100644 (file)
index 0000000..dd77c68
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_070.phpt
@@ -0,0 +1,49 @@
+--TEST--
+Test typed static property with assign op operators
+--FILE--
+<?php
+function &stringRef() {
+       static $a = "1";
+       $b = $a;
+       $a = &$b;
+       return $a;
+}
+
+class Foo {
+       public static int $i = 0;
+       public static string $s = "1";
+}
+
+Foo::$s .= "1";
+var_dump(Foo::$s);
+
+Foo::$s += 2;
+var_dump(Foo::$s);
+
+Foo::$s = &stringRef();
+Foo::$s .= 2;
+var_dump(Foo::$s);
+
+Foo::$i += stringRef();
+var_dump(Foo::$i);
+
+try {
+       Foo::$i += PHP_INT_MAX;
+} catch (TypeError $e) { print $e->getMessage()."\n"; }
+var_dump(Foo::$i);
+
+try {
+       Foo::$i .= PHP_INT_MAX;
+} catch (TypeError $e) { print $e->getMessage()."\n"; }
+var_dump(Foo::$i);
+
+?>
+--EXPECT--
+string(2) "11"
+string(2) "13"
+string(2) "12"
+int(1)
+Typed property Foo::$i must be int, float used
+int(1)
+Typed property Foo::$i must be int, string used
+int(1)

diff --git a/Zend/tests/type_declarations/typed_properties_071.phpt b/Zend/tests/type_declarations/typed_properties_071.phpt
new file mode 100644 (file)
index 0000000..4d0451c
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_071.phpt
@@ -0,0 +1,36 @@
+--TEST--
+Test assignment to typed reference with weak type conversion
+--FILE--
+<?php
+  
+class Test {
+    public string $x = "x";
+}
+
+$test = new Test;
+var_dump($test);
+$y = "y";
+$test->x = &$y;
+var_dump($y, $test);
+
+$z = 42;
+$y = $z;
+var_dump($y, $z, $test);
+
+?>
+--EXPECT--
+object(Test)#1 (1) {
+  ["x"]=>
+  string(1) "x"
+}
+string(1) "y"
+object(Test)#1 (1) {
+  ["x"]=>
+  &string(1) "y"
+}
+string(2) "42"
+int(42)
+object(Test)#1 (1) {
+  ["x"]=>
+  &string(2) "42"
+}

diff --git a/Zend/tests/type_declarations/typed_properties_072.phpt b/Zend/tests/type_declarations/typed_properties_072.phpt
new file mode 100644 (file)
index 0000000..b56c5d6
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_072.phpt
@@ -0,0 +1,24 @@
+--TEST--
+Typed property must cast when used with __get()
+--FILE--
+<?php
+  
+class Test {
+       public int $val;
+
+       public function __get($name) {
+               return "42";
+       }
+}
+
+$test = new Test;
+var_dump($test);
+var_dump($test->val);
+
+?>
+--EXPECT--
+object(Test)#1 (0) {
+  ["val"]=>
+  uninitialized(int)
+}
+int(42)

diff --git a/Zend/tests/type_declarations/typed_properties_073.phpt b/Zend/tests/type_declarations/typed_properties_073.phpt
new file mode 100644 (file)
index 0000000..7f9b4ff
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_073.phpt
@@ -0,0 +1,44 @@
+--TEST--
+Typed property must cast when used with &__get()
+--FILE--
+<?php
+  
+class Test {
+       public $prop = "42";
+       public int $val;
+
+       public function &__get($name) {
+               return $this->prop;
+       }
+}
+
+$test = new Test;
+var_dump($test);
+var_dump($val = &$test->val);
+var_dump($test);
+
+$test->prop = "x";
+var_dump($test, $val);
+
+?>
+--EXPECT--
+object(Test)#1 (1) {
+  ["prop"]=>
+  string(2) "42"
+  ["val"]=>
+  uninitialized(int)
+}
+int(42)
+object(Test)#1 (1) {
+  ["prop"]=>
+  &int(42)
+  ["val"]=>
+  uninitialized(int)
+}
+object(Test)#1 (1) {
+  ["prop"]=>
+  &string(1) "x"
+  ["val"]=>
+  uninitialized(int)
+}
+string(1) "x"

diff --git a/Zend/tests/type_declarations/typed_properties_074.phpt b/Zend/tests/type_declarations/typed_properties_074.phpt
new file mode 100644 (file)
index 0000000..8e6be31
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_074.phpt
@@ -0,0 +1,41 @@
+--TEST--
+Typed property must be compatible when returned via &__get()
+--FILE--
+<?php
+  
+class Test {
+       public $prop = "x";
+       public int $val;
+
+       public function &__get($name) {
+               return $this->prop;
+       }
+}
+
+$test = new Test;
+$dummyRef = &$test->prop;
+var_dump($test);
+try {
+       var_dump($test->val);
+} catch (TypeError $e) { print $e->getMessage()."\n"; }
+var_dump($test);
+
+$test->prop = "y";
+var_dump($test->prop);
+
+?>
+--EXPECT--
+object(Test)#1 (1) {
+  ["prop"]=>
+  &string(1) "x"
+  ["val"]=>
+  uninitialized(int)
+}
+Typed property Test::$val must be int, string used
+object(Test)#1 (1) {
+  ["prop"]=>
+  &string(1) "x"
+  ["val"]=>
+  uninitialized(int)
+}
+string(1) "y"

diff --git a/Zend/tests/type_declarations/typed_properties_075.phpt b/Zend/tests/type_declarations/typed_properties_075.phpt
new file mode 100644 (file)
index 0000000..5f3943c
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_075.phpt
@@ -0,0 +1,53 @@
+--TEST--
+Test typed properties overflowing
+--SKIPIF--
+<?php if (PHP_INT_SIZE == 4) die("SKIP: 64 bit test"); ?>
+--FILE--
+<?php
+
+class Foo {
+       public static int $bar = PHP_INT_MAX;
+};
+
+try {
+       Foo::$bar++;
+} catch(TypeError $t) {
+       var_dump($t->getMessage());
+}
+
+var_dump(Foo::$bar);
+
+try {
+       Foo::$bar += 1;
+} catch(TypeError $t) {
+       var_dump($t->getMessage());
+}
+
+var_dump(Foo::$bar);
+
+try {
+       ++Foo::$bar;
+} catch(TypeError $t) {
+       var_dump($t->getMessage());
+}
+
+var_dump(Foo::$bar);
+
+try {
+       Foo::$bar = Foo::$bar + 1;
+} catch(TypeError $t) {
+       var_dump($t->getMessage());
+}
+
+var_dump(Foo::$bar);
+
+?>
+--EXPECT--
+string(70) "Cannot increment property Foo::$bar of type int past its maximal value"
+int(9223372036854775807)
+string(48) "Typed property Foo::$bar must be int, float used"
+int(9223372036854775807)
+string(70) "Cannot increment property Foo::$bar of type int past its maximal value"
+int(9223372036854775807)
+string(48) "Typed property Foo::$bar must be int, float used"
+int(9223372036854775807)

diff --git a/Zend/tests/type_declarations/typed_properties_076.phpt b/Zend/tests/type_declarations/typed_properties_076.phpt
new file mode 100644 (file)
index 0000000..b0d0bfe
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_076.phpt
@@ -0,0 +1,71 @@
+--TEST--
+Computation of intersection types for typed reference to typed property assignments
+--FILE--
+<?php
+
+class A {}
+class B extends A {}
+
+class Test {
+    public int $int;
+    public float $float;
+    public ?int $nint;
+    public ?string $nstring;
+    public array $array;
+    public object $object;
+    public iterable $iterable;
+    public Iterator $Iterator;
+    public A $A;
+    public B $B;
+}
+
+function invalid(Test $test, string $prop1, string $prop2, $value) {
+    try {
+        $test->$prop2 = $value;
+        $test->$prop1 =& $test->$prop2;
+        echo "Invalid assignment $prop1 =& $prop2 did not error\n";
+    } catch (TypeError $e) {}
+    try {
+        $test->$prop1 = $value;
+        $test->$prop2 =& $test->$prop1;
+        echo "Invalid assignment $prop2 =& $prop1 did not error\n";
+    } catch (TypeError $e) {}
+}
+
+function valid(Test $test, string $prop1, string $prop2, $value) {
+    try {
+        $test->$prop2 = $value;
+        $test->$prop1 =& $test->$prop2;
+    } catch (TypeError $e) {
+        echo "Valid assignment $prop1 =& $prop2 threw {$e->getMessage()}\n";
+    }
+    try {
+        $test->$prop1 = $value;
+        $test->$prop2 =& $test->$prop1;
+    } catch (TypeError $e) {
+        echo "Valid assignment $prop2 =& $prop1 threw {$e->getMessage()}\n";
+    }
+}
+
+$test = new Test;
+invalid($test, 'int', 'float', 42.0);
+valid($test, 'int', 'nint', 42);
+invalid($test, 'int', 'nint', null);
+valid($test, 'nint', 'nstring', null);
+invalid($test, 'nint', 'nstring', '42');
+valid($test, 'A', 'A', new A);
+valid($test, 'A', 'B', new B);
+invalid($test, 'A', 'B', new A);
+valid($test, 'iterable', 'array', [1, 2, 3]);
+valid($test, 'A', 'object', new A);
+invalid($test, 'A', 'object', new Test);
+valid($test, 'iterable', 'Iterator', new ArrayIterator);
+invalid($test, 'Iterator', 'iterable', [1, 2, 3]);
+valid($test, 'object', 'iterable', new ArrayIterator);
+invalid($test, 'iterable', 'object', new stdClass);
+
+echo "Done\n";
+
+?>
+--EXPECT--
+Done

diff --git a/Zend/tests/type_declarations/typed_properties_077.phpt b/Zend/tests/type_declarations/typed_properties_077.phpt
new file mode 100644 (file)
index 0000000..4e26403
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_077.phpt
@@ -0,0 +1,18 @@
+--TEST--
+Converted values shall be returned and not the original value upon property assignment
+--FILE--
+<?php
+
+class Test {
+    public int $i;
+    public string $s;
+}
+
+$test = new Test;
+var_dump($test->i = "42");
+var_dump($test->s = 42);
+
+?>
+--EXPECT--
+int(42)
+string(2) "42"

diff --git a/Zend/tests/type_declarations/typed_properties_078.phpt b/Zend/tests/type_declarations/typed_properties_078.phpt
new file mode 100644 (file)
index 0000000..6645970
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_078.phpt
@@ -0,0 +1,59 @@
+--TEST--
+Typed references must be kept track of and always be only the intersection of the types currently holding that reference
+--FILE--
+<?php
+
+$a = new class {
+       public ?iterable $it = [];
+       public ?array $a;
+       public ?Traversable $t;
+};
+
+$ref = &$a->it;
+$a->a = &$ref;
+
+var_dump($ref);
+
+try {
+       $a->t = &$ref;
+} catch (TypeError $e) { var_dump($e->getMessage()); }
+var_dump($ref);
+
+$a->it = [1]; // type is still assignable
+var_dump($ref);
+
+try {
+       $ref = new ArrayIterator();
+} catch (TypeError $e) { var_dump($e->getMessage()); }
+var_dump($ref instanceof ArrayIterator);
+
+unset($a->a);
+
+$ref = null;
+
+$a->t = &$ref;
+
+try {
+       $ref = [];
+} catch (TypeError $e) { var_dump($e->getMessage()); }
+var_dump($ref instanceof ArrayIterator);
+
+$ref = new ArrayIterator();
+var_dump($ref instanceof ArrayIterator);
+
+?>
+--EXPECT--
+array(0) {
+}
+string(89) "Typed property class@anonymous::$t must be an instance of Traversable or null, array used"
+array(0) {
+}
+array(1) {
+  [0]=>
+  int(1)
+}
+string(92) "Cannot assign ArrayIterator to reference held by property class@anonymous::$a of type ?array"
+bool(false)
+string(90) "Cannot assign array to reference held by property class@anonymous::$t of type ?Traversable"
+bool(false)
+bool(true)

diff --git a/Zend/tests/type_declarations/typed_properties_079.phpt b/Zend/tests/type_declarations/typed_properties_079.phpt
new file mode 100644 (file)
index 0000000..85ed6fc
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_079.phpt
@@ -0,0 +1,33 @@
+--TEST--
+Test static typed properties with references
+--FILE--
+<?php
+
+class A {
+       static iterable $it = [];
+       static ?array $a;
+}
+
+A::$a = &A::$it;
+
+try {
+       A::$it = new ArrayIterator();
+} catch (TypeError $e) { var_dump($e->getMessage()); }
+var_dump(A::$it);
+
+A::$a = &$a;
+
+A::$it = new ArrayIterator();
+
+try {
+       $a = 1;
+} catch (TypeError $e) { var_dump($e->getMessage()); }
+var_dump($a);
+
+?>
+--EXPECT--
+string(78) "Cannot assign ArrayIterator to reference held by property A::$a of type ?array"
+array(0) {
+}
+string(68) "Cannot assign int to reference held by property A::$a of type ?array"
+NULL

diff --git a/Zend/tests/type_declarations/typed_properties_080.phpt b/Zend/tests/type_declarations/typed_properties_080.phpt
new file mode 100644 (file)
index 0000000..58a17a1
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_080.phpt
@@ -0,0 +1,36 @@
+--TEST--
+Access to typed static properties before initialization
+--FILE--
+<?php
+
+class Test {
+    public static int $a;
+    protected static int $b;
+    private static int $c;
+
+    static function run() {
+        try {
+            self::$a;
+        } catch (Error $e) {
+            echo $e->getMessage(), "\n";
+        }
+        try {
+            self::$b;
+        } catch (Error $e) {
+            echo $e->getMessage(), "\n";
+        }
+        try {
+            self::$c;
+        } catch (Error $e) {
+            echo $e->getMessage(), "\n";
+        }
+    }
+}
+
+Test::run();
+
+?>
+--EXPECT--
+Typed static property Test::$a must not be accessed before initialization
+Typed static property Test::$b must not be accessed before initialization
+Typed static property Test::$c must not be accessed before initialization

diff --git a/Zend/tests/type_declarations/typed_properties_081.phpt b/Zend/tests/type_declarations/typed_properties_081.phpt
new file mode 100644 (file)
index 0000000..4f49eae
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_081.phpt
@@ -0,0 +1,22 @@
+--TEST--
+Clone must inherit typed references
+--FILE--
+<?php
+
+class Test {
+    public int $x = 42;
+}
+
+$test = new Test;
+$x =& $test->x;
+$test2 = clone $test;
+unset($test);
+try {
+       $x = "foo";
+} catch (TypeError $e) { echo $e->getMessage(), "\n"; }
+var_dump($test2->x);
+
+?>
+--EXPECT--
+Cannot assign string to reference held by property Test::$x of type int
+int(42)

diff --git a/Zend/tests/type_declarations/typed_properties_082.phpt b/Zend/tests/type_declarations/typed_properties_082.phpt
new file mode 100644 (file)
index 0000000..1e4e62e
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_082.phpt
@@ -0,0 +1,30 @@
+--TEST--
+Test typed references to static properties 
+--FILE--
+<?php
+
+class Test {
+       public static int $x = 0;
+}
+
+class Test2 extends Test {
+       public static $y = 1;
+}
+
+$x =& Test::$x;
+try {
+       $x = "foo";
+} catch (TypeError $e) { echo $e->getMessage(), "\n"; }
+var_dump($x, Test::$x);
+
+Test::$x =& Test2::$y; // remove the typed ref from $x
+$x = "foo";
+var_dump($x, Test::$x);
+
+?>
+--EXPECT--
+Cannot assign string to reference held by property Test::$x of type int
+int(0)
+int(0)
+string(3) "foo"
+int(1)

diff --git a/Zend/tests/type_declarations/typed_properties_083.phpt b/Zend/tests/type_declarations/typed_properties_083.phpt
new file mode 100644 (file)
index 0000000..f67eec3
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_083.phpt
@@ -0,0 +1,80 @@
+--TEST--
+Test array promotion does not violate type restrictions
+--FILE--
+<?php
+
+class Foo {
+    public ?string $p;
+    public ?iterable $i;
+    public static ?string $s;
+    public static ?array $a;
+}
+
+$a = new Foo;
+
+$a->i[] = 1;
+var_dump($a->i);
+
+try {
+    $a->p[] = "test";
+} catch (TypeError $e) { var_dump($e->getMessage()); }
+try { // must be uninit
+    var_dump($a->p); // WRONG!
+} catch (Error $e) { var_dump($e->getMessage()); }
+
+$a->p = null;
+try {
+    $a->p[] = "test";
+} catch (TypeError $e) { var_dump($e->getMessage()); }
+var_dump($a->p);
+
+Foo::$a["bar"] = 2;
+var_dump(Foo::$a);
+
+try {
+    Foo::$s["baz"][] = "baz";
+} catch (TypeError $e) { var_dump($e->getMessage()); }
+try { // must be uninit
+    var_dump(Foo::$s);
+} catch (Error $e) { var_dump($e->getMessage()); }
+
+Foo::$a = null;
+$ref = &Foo::$a;
+$ref[] = 3;
+var_dump($ref);
+
+$ref = &$a->p;
+try {
+    $ref[] = "bar";
+} catch (TypeError $e) { var_dump($e->getMessage()); }
+var_dump($ref);
+
+try {
+    $ref["baz"][] = "bar"; // indirect assign
+} catch (TypeError $e) { var_dump($e->getMessage()); }
+var_dump($ref);
+
+?>
+--EXPECT--
+array(1) {
+  [0]=>
+  int(1)
+}
+string(71) "Cannot auto-initialize an array inside property Foo::$p of type ?string"
+string(65) "Typed property Foo::$p must not be accessed before initialization"
+string(71) "Cannot auto-initialize an array inside property Foo::$p of type ?string"
+NULL
+array(1) {
+  ["bar"]=>
+  int(2)
+}
+string(71) "Cannot auto-initialize an array inside property Foo::$s of type ?string"
+string(72) "Typed static property Foo::$s must not be accessed before initialization"
+array(1) {
+  [0]=>
+  int(3)
+}
+string(91) "Cannot auto-initialize an array inside a reference held by property Foo::$p of type ?string"
+NULL
+string(91) "Cannot auto-initialize an array inside a reference held by property Foo::$p of type ?string"
+NULL

diff --git a/Zend/tests/type_declarations/typed_properties_084.phpt b/Zend/tests/type_declarations/typed_properties_084.phpt
new file mode 100644 (file)
index 0000000..fb3c861
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_084.phpt
@@ -0,0 +1,25 @@
+--TEST--
+Typed properties and class aliases
+--FILE--
+<?php
+eval(<<<'PHP'
+class Foo {}
+class_alias('Foo', 'Bar');
+PHP);
+ 
+eval(<<<'PHP'
+class A {
+    public Foo $prop;
+}
+PHP);
+
+eval(<<<'PHP'
+class B extends A {
+    public Bar $prop;
+}
+PHP);
+
+?>
+===DONE===
+--EXPECT--
+===DONE===

diff --git a/Zend/tests/type_declarations/typed_properties_085.phpt b/Zend/tests/type_declarations/typed_properties_085.phpt
new file mode 100644 (file)
index 0000000..ccac376
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_085.phpt
@@ -0,0 +1,17 @@
+--TEST--
+Important properties with different types from traits
+--FILE--
+<?php
+
+trait T1 {
+    public int $prop;
+}
+trait T2 {
+    public string $prop;
+}
+class C {
+    use T1, T2;
+}
+?>
+--EXPECTF--
+Fatal error: T1 and T2 define the same property ($prop) in the composition of C. However, the definition differs and is considered incompatible. Class was composed in %s on line %d

diff --git a/Zend/tests/type_declarations/typed_properties_086.phpt b/Zend/tests/type_declarations/typed_properties_086.phpt
new file mode 100644 (file)
index 0000000..c58eb78
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_086.phpt
@@ -0,0 +1,27 @@
+--TEST--
+Test typed properties with integer keys
+--FILE--
+<?php
+
+class T {
+       // Class must have at least one property. Property must have a type.
+       // Empty class or untyped property removes segfault
+       public int $i;
+}
+
+$t = new T;
+// $x must be undefined or a non-string type
+$x = 1;
+$t->$x = 2;
+$t->$x--;
+
+var_dump($t);
+
+?>
+--EXPECT--
+object(T)#1 (1) {
+  ["i"]=>
+  uninitialized(int)
+  ["1"]=>
+  int(1)
+}

diff --git a/Zend/tests/type_declarations/typed_properties_087.phpt b/Zend/tests/type_declarations/typed_properties_087.phpt
new file mode 100644 (file)
index 0000000..b981dfc
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_087.phpt
@@ -0,0 +1,15 @@
+--TEST--
+Ensure null-initialization of nullable typed static property taken by reference
+--FILE--
+<?php
+
+class A {
+    public static ?int $a;
+}
+
+$x =& A::$a;
+var_dump($x);
+
+?>
+--EXPECT--
+NULL

diff --git a/Zend/tests/type_declarations/typed_properties_088.phpt b/Zend/tests/type_declarations/typed_properties_088.phpt
new file mode 100644 (file)
index 0000000..b2f626d
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_088.phpt
@@ -0,0 +1,30 @@
+--TEST--
+Check for correct invalidation of prop_info cache slots
+--FILE--
+<?php
+
+class A {
+    public int $prop;
+}
+class B {
+    public $prop;
+}
+
+function test($obj) {
+    $obj->prop = "42";
+    var_dump($obj);
+}
+
+test(new A);
+test(new B);
+
+?>
+--EXPECT--
+object(A)#1 (1) {
+  ["prop"]=>
+  int(42)
+}
+object(B)#1 (1) {
+  ["prop"]=>
+  string(2) "42"
+}

diff --git a/Zend/tests/type_declarations/typed_properties_089.phpt b/Zend/tests/type_declarations/typed_properties_089.phpt
new file mode 100644 (file)
index 0000000..1d59b8d
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_089.phpt
@@ -0,0 +1,38 @@
+--TEST--
+Modification of typed property during assignment must not leak
+--FILE--
+<?php
+
+class A {
+       public string $prop = "";
+}
+
+class B {
+       public function __toString() {
+               global $a;
+               $a->prop = "dont ";
+               $a->prop .= "leak ";
+               $a->prop .= "me!";
+               return "test";
+       }
+}
+
+$a = new A;
+$a->prop = new B;
+var_dump($a);
+
+$a = new A;
+$prop = &$a->prop;
+$a->prop = new B;
+var_dump($a);
+
+?>
+--EXPECTF--
+object(A)#1 (1) {
+  ["prop"]=>
+  string(4) "test"
+}
+object(A)#%d (1) {
+  ["prop"]=>
+  &string(4) "test"
+}

diff --git a/Zend/tests/type_declarations/typed_properties_090.phpt b/Zend/tests/type_declarations/typed_properties_090.phpt
new file mode 100644 (file)
index 0000000..3b75aaa
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_090.phpt
@@ -0,0 +1,25 @@
+--TEST--
+Unsetting typed properties containing a reference must respect shadowing
+--FILE--
+<?php
+
+class A {
+       private int $prop = 42;
+
+       public function test() {
+               $x =& $this->prop;
+               unset($this->prop);
+               $x = "foo";
+               var_dump($x);
+       }
+}
+class B extends A {
+       private $prop;
+}
+
+$b = new B;
+$b->test();
+
+?>
+--EXPECT--
+string(3) "foo"

diff --git a/Zend/tests/type_declarations/typed_properties_091.phpt b/Zend/tests/type_declarations/typed_properties_091.phpt
new file mode 100644 (file)
index 0000000..7d6b54a
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_091.phpt
@@ -0,0 +1,199 @@
+--TEST--
+Automatic promotion of falsy to object
+--FILE--
+<?php
+
+class Test {
+    public ?Test $prop;
+    public ?stdClass $stdProp;
+    public ?object $objectProp;
+
+    public static ?Test $staticProp = null;
+    public static ?stdClass $staticStdProp = null;
+    public static ?object $staticObjectProp = null;
+}
+
+// Object properties
+$test = new Test;
+try {
+    $test->prop->wat = 123;
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+$test->stdProp->wat = 123;
+$test->objectProp->wat = 123;
+var_dump($test);
+
+// Object properties via reference
+$test = new Test;
+$prop =& $test->prop;
+$stdProp =& $test->stdProp;
+$objectProp =& $test->objectProp;
+try {
+    $prop->wat = 123;
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+$stdProp->wat = 123;
+$objectProp->wat = 123;
+var_dump($test);
+
+// Object properties via reference rw
+$test = new Test;
+$prop =& $test->prop;
+$stdProp =& $test->stdProp;
+$objectProp =& $test->objectProp;
+try {
+    $prop->wat->wat = 123;
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+$stdProp->wat->wat = 123;
+$objectProp->wat->wat = 123;
+var_dump($test);
+
+// Static properties
+try {
+    Test::$staticProp->wat = 123;
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+Test::$staticStdProp->wat = 123;
+Test::$staticObjectProp->wat = 123;
+var_dump(Test::$staticProp, Test::$staticStdProp, Test::$staticObjectProp);
+
+// Non-string property name
+$test = new Test;
+$propName = new class {
+    public function __toString() {
+        return 'prop';
+    }
+};
+try {
+    $test->$propName->wat = 123;
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+var_dump($test);
+
+// Initially null
+$test = new Test;
+$test->prop = NULL;
+$test->stdProp = NULL;
+$test->objectProp = NULL;
+try {
+    $test->prop->wat = 123;
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+$test->stdProp->wat = 123;
+$test->objectProp->wat = 123;
+var_dump($test);
+
+?>
+--EXPECTF--
+Cannot auto-initialize an stdClass inside property Test::$prop of type ?Test
+
+Warning: Creating default object from empty value in %s on line %d
+
+Warning: Creating default object from empty value in %s on line %d
+object(Test)#1 (2) {
+  ["prop"]=>
+  uninitialized(?Test)
+  ["stdProp"]=>
+  object(stdClass)#3 (1) {
+    ["wat"]=>
+    int(123)
+  }
+  ["objectProp"]=>
+  object(stdClass)#4 (1) {
+    ["wat"]=>
+    int(123)
+  }
+}
+Cannot auto-initialize an stdClass inside a reference held by property Test::$prop of type ?Test
+
+Warning: Creating default object from empty value in %s on line %d
+
+Warning: Creating default object from empty value in %s on line %d
+object(Test)#5 (3) {
+  ["prop"]=>
+  &NULL
+  ["stdProp"]=>
+  &object(stdClass)#2 (1) {
+    ["wat"]=>
+    int(123)
+  }
+  ["objectProp"]=>
+  &object(stdClass)#4 (1) {
+    ["wat"]=>
+    int(123)
+  }
+}
+Cannot auto-initialize an stdClass inside a reference held by property Test::$prop of type ?Test
+
+Warning: Creating default object from empty value in %s on line %d
+
+Warning: Creating default object from empty value in %s on line %d
+object(Test)#3 (3) {
+  ["prop"]=>
+  &NULL
+  ["stdProp"]=>
+  &object(stdClass)#1 (1) {
+    ["wat"]=>
+    object(stdClass)#2 (1) {
+      ["wat"]=>
+      int(123)
+    }
+  }
+  ["objectProp"]=>
+  &object(stdClass)#5 (1) {
+    ["wat"]=>
+    object(stdClass)#6 (1) {
+      ["wat"]=>
+      int(123)
+    }
+  }
+}
+Cannot auto-initialize an stdClass inside property Test::$staticProp of type ?Test
+
+Warning: Creating default object from empty value in %s on line %d
+
+Warning: Creating default object from empty value in %s on line %d
+NULL
+object(stdClass)#4 (1) {
+  ["wat"]=>
+  int(123)
+}
+object(stdClass)#8 (1) {
+  ["wat"]=>
+  int(123)
+}
+Cannot auto-initialize an stdClass inside property Test::$prop of type ?Test
+object(Test)#9 (0) {
+  ["prop"]=>
+  uninitialized(?Test)
+  ["stdProp"]=>
+  uninitialized(?stdClass)
+  ["objectProp"]=>
+  uninitialized(?object)
+}
+Cannot auto-initialize an stdClass inside property Test::$prop of type ?Test
+
+Warning: Creating default object from empty value in %s on line %d
+
+Warning: Creating default object from empty value in %s on line %d
+object(Test)#7 (3) {
+  ["prop"]=>
+  NULL
+  ["stdProp"]=>
+  object(stdClass)#10 (1) {
+    ["wat"]=>
+    int(123)
+  }
+  ["objectProp"]=>
+  object(stdClass)#11 (1) {
+    ["wat"]=>
+    int(123)
+  }
+}

diff --git a/Zend/tests/type_declarations/typed_properties_092.phpt b/Zend/tests/type_declarations/typed_properties_092.phpt
new file mode 100644 (file)
index 0000000..8509fa7
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_092.phpt
@@ -0,0 +1,41 @@
+--TEST--
+Refs on ASSIGN_OBJ fast-path
+--FILE--
+<?php
+
+function &ref(&$foo) {
+    return $foo;
+}
+
+class Test {
+    public array $prop;
+    public int $prop2;
+
+    public function foo() {
+        $array = [];
+        $ref =& $array;
+        $this->prop = $array;
+    }
+
+    public function bar() {
+        $str = "123";
+        $this->prop2 = ref($str);
+    }
+}
+
+$test = new Test;
+$test->foo();
+$test->foo();
+$test->bar();
+$test->bar();
+var_dump($test);
+
+?>
+--EXPECT--
+object(Test)#1 (2) {
+  ["prop"]=>
+  array(0) {
+  }
+  ["prop2"]=>
+  int(123)
+}

diff --git a/Zend/tests/type_declarations/typed_properties_093.phpt b/Zend/tests/type_declarations/typed_properties_093.phpt
new file mode 100644 (file)
index 0000000..f0c7ef5
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_093.phpt
@@ -0,0 +1,31 @@
+--TEST--
+Typed property assignment by ref with variable name
+--FILE--
+<?php
+
+class Test {
+    public int $prop;
+}
+
+$name = new class {
+    public function __toString() {
+        return 'prop';
+    }
+};
+
+$test = new Test;
+$ref = "foobar";
+try {
+    $test->$name =& $ref;
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+var_dump($test);
+
+?>
+--EXPECT--
+Typed property Test::$prop must be int, string used
+object(Test)#2 (0) {
+  ["prop"]=>
+  uninitialized(int)
+}

diff --git a/Zend/tests/type_declarations/typed_properties_094.phpt b/Zend/tests/type_declarations/typed_properties_094.phpt
new file mode 100644 (file)
index 0000000..0fbcb7e
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_094.phpt
@@ -0,0 +1,36 @@
+--TEST--
+Edge cases relating to reference source tracking
+--FILE--
+<?php
+
+class A {
+    public int $prop = 42;
+}
+class B extends A {
+}
+
+$b = new B;
+$r =& $b->prop;
+unset($b);
+$r = "foo"; // ok
+
+class A2 {
+    private int $prop = 42;
+
+    public function &getRef() {
+        return $this->prop;
+    }
+}
+class B2 extends A2 {
+    public $prop;
+}
+
+$b2 = new B2;
+$r2 =& $b2->getRef();
+unset($b2);
+$r2 = "foo"; // ok
+
+?>
+===DONE===
+--EXPECT--
+===DONE===

diff --git a/Zend/tests/type_declarations/typed_properties_095.phpt b/Zend/tests/type_declarations/typed_properties_095.phpt
new file mode 100644 (file)
index 0000000..edbef8d
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_095.phpt
@@ -0,0 +1,84 @@
+--TEST--
+Typed properties in internal classes
+--SKIPIF--
+<?php if (!extension_loaded('zend-test')) die('skip requires zend-test'); ?>
+--FILE--
+<?php
+
+// Internal typed properties
+
+$obj = new _ZendTestClass;
+var_dump($obj->intProp);
+try {
+    $obj->intProp = "foobar";
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+$obj->intProp = 456;
+
+try {
+    $obj->classProp = $obj;
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+$obj->classProp = new stdClass;
+var_dump($obj);
+
+// Inherit from internal class
+
+class Test extends _ZendTestClass {
+}
+
+$obj = new Test;
+var_dump($obj->intProp);
+try {
+    $obj->intProp = "foobar";
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+$obj->intProp = 456;
+
+try {
+    $obj->classProp = $obj;
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+$obj->classProp = new stdClass;
+var_dump($obj);
+
+// Static internal typed properties
+
+var_dump(_ZendTestClass::$staticIntProp);
+try {
+    _ZendTestClass::$staticIntProp = "foobar";
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+_ZendTestClass::$staticIntProp = 456;
+var_dump(_ZendTestClass::$staticIntProp);
+
+?>
+--EXPECT--
+int(123)
+Typed property _ZendTestClass::$intProp must be int, string used
+Typed property _ZendTestClass::$classProp must be an instance of stdClass or null, _ZendTestClass used
+object(_ZendTestClass)#1 (2) {
+  ["intProp"]=>
+  int(456)
+  ["classProp"]=>
+  object(stdClass)#2 (0) {
+  }
+}
+int(123)
+Typed property _ZendTestClass::$intProp must be int, string used
+Typed property _ZendTestClass::$classProp must be an instance of stdClass or null, Test used
+object(Test)#4 (2) {
+  ["intProp"]=>
+  int(456)
+  ["classProp"]=>
+  object(stdClass)#1 (0) {
+  }
+}
+int(123)
+Typed property _ZendTestClass::$staticIntProp must be int, string used
+int(456)

diff --git a/Zend/tests/type_declarations/typed_properties_096.phpt b/Zend/tests/type_declarations/typed_properties_096.phpt
new file mode 100644 (file)
index 0000000..32191b2
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_096.phpt
@@ -0,0 +1,46 @@
+--TEST--
+References to typed properties with undefined classes
+--FILE--
+<?php
+
+class Test1 {
+    public Foobar $prop;
+    public int $prop2;
+}
+
+$test = new Test1;
+$test->prop2 = 123;
+$ref =& $test->prop2;
+try {
+    $test->prop =& $ref;
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+var_dump($test);
+
+class Test2 {
+    public ?Foobar $prop;
+    public ?int $prop2;
+}
+
+$test = new Test2;
+$test->prop2 = null;
+$ref =& $test->prop2;
+$test->prop =& $ref;
+var_dump($test);
+
+?>
+--EXPECT--
+Typed property Test1::$prop must be an instance of Foobar, int used
+object(Test1)#1 (1) {
+  ["prop"]=>
+  uninitialized(Foobar)
+  ["prop2"]=>
+  &int(123)
+}
+object(Test2)#3 (2) {
+  ["prop"]=>
+  &NULL
+  ["prop2"]=>
+  &NULL
+}

diff --git a/Zend/tests/type_declarations/typed_properties_097.phpt b/Zend/tests/type_declarations/typed_properties_097.phpt
new file mode 100644 (file)
index 0000000..b00f059
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_097.phpt
@@ -0,0 +1,90 @@
+--TEST--
+Incrementing/decrementing past max/min value (additional cases)
+--SKIPIF--
+<?php if (PHP_INT_SIZE != 8) die('skip 64 bit test'); ?>
+--FILE--
+<?php
+
+class Test {
+    public int $foo;
+}
+
+$test = new Test;
+
+$test->foo = PHP_INT_MIN;
+try {
+    --$test->foo;
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+var_dump($test->foo);
+try {
+    $test->foo--;
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+var_dump($test->foo);
+
+$test->foo = PHP_INT_MAX;
+try {
+    ++$test->foo;
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+var_dump($test->foo);
+try {
+    $test->foo++;
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+var_dump($test->foo);
+
+// Do the same things again, but with the property being a reference.
+$ref =& $test->foo;
+
+$test->foo = PHP_INT_MIN;
+try {
+    --$test->foo;
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+var_dump($test->foo);
+try {
+    $test->foo--;
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+var_dump($test->foo);
+
+$test->foo = PHP_INT_MAX;
+try {
+    ++$test->foo;
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+var_dump($test->foo);
+try {
+    $test->foo++;
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+var_dump($test->foo);
+
+?>
+--EXPECT--
+Cannot decrement property Test::$foo of type int past its minimal value
+int(-9223372036854775808)
+Cannot decrement property Test::$foo of type int past its minimal value
+int(-9223372036854775808)
+Cannot increment property Test::$foo of type int past its maximal value
+int(9223372036854775807)
+Cannot increment property Test::$foo of type int past its maximal value
+int(9223372036854775807)
+Cannot decrement property Test::$foo of type int past its minimal value
+int(-9223372036854775808)
+Cannot decrement property Test::$foo of type int past its minimal value
+int(-9223372036854775808)
+Cannot increment property Test::$foo of type int past its maximal value
+int(9223372036854775807)
+Cannot increment property Test::$foo of type int past its maximal value
+int(9223372036854775807)

diff --git a/Zend/tests/type_declarations/typed_properties_098.phpt b/Zend/tests/type_declarations/typed_properties_098.phpt
new file mode 100644 (file)
index 0000000..48e443c
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_098.phpt
@@ -0,0 +1,17 @@
+--TEST--
+Make sure uninitialized property is initialized to null when taken by reference
+--FILE--
+<?php
+
+class Test {
+    public $prop;
+}
+
+$test = new Test;
+unset($test->prop);
+$ref =& $test->prop;
+var_dump($ref);
+
+?>
+--EXPECT--
+NULL

diff --git a/Zend/tests/type_declarations/typed_properties_099.phpt b/Zend/tests/type_declarations/typed_properties_099.phpt
new file mode 100644 (file)
index 0000000..1e450ce
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_099.phpt
@@ -0,0 +1,20 @@
+--TEST--
+Check that iterating a typed property by reference adds a type source
+--FILE--
+<?php
+
+class Test {
+    public array $ary = [];
+}
+
+$test = new Test;
+foreach ($test->ary as &$value) {}
+var_dump($test);
+
+?>
+--EXPECT--
+object(Test)#1 (1) {
+  ["ary"]=>
+  array(0) {
+  }
+}

diff --git a/Zend/tests/type_declarations/typed_properties_100.phpt b/Zend/tests/type_declarations/typed_properties_100.phpt
new file mode 100644 (file)
index 0000000..8ee3deb
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_100.phpt
@@ -0,0 +1,19 @@
+--TEST--
+Property type not enforced for __get if the property is not visible
+--FILE--
+<?php
+  
+class Test {
+    private int $prop;
+
+    public function __get($name) {
+        return "foobar";
+    }
+}
+
+$test = new Test;
+var_dump($test->prop);
+
+?>
+--EXPECT--
+string(6) "foobar"

diff --git a/Zend/tests/type_declarations/typed_properties_101.phpt b/Zend/tests/type_declarations/typed_properties_101.phpt
new file mode 100644 (file)
index 0000000..3c5a15f
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_101.phpt
@@ -0,0 +1,37 @@
+--TEST--
+Dumping of uninitialized typed properties (including private ones)
+--FILE--
+<?php
+
+class Test {
+    public bool $public;
+    protected float $protected;
+    private string $private;
+
+    public function dump() {
+        var_dump($this);
+        debug_zval_dump($this);
+    }
+}
+
+$test = new Test;
+$test->dump();
+
+?>
+--EXPECTF--
+object(Test)#1 (0) {
+  ["public"]=>
+  uninitialized(bool)
+  ["protected":protected]=>
+  uninitialized(float)
+  ["private":"Test":private]=>
+  uninitialized(string)
+}
+object(Test)#1 (0) refcount(%d){
+  ["public"]=>
+  uninitialized(bool)
+  ["protected":protected]=>
+  uninitialized(float)
+  ["private":"Test":private]=>
+  uninitialized(string)
+}

diff --git a/Zend/tests/type_declarations/typed_properties_102.phpt b/Zend/tests/type_declarations/typed_properties_102.phpt
new file mode 100644 (file)
index 0000000..83f3c26
--- /dev/null
+++ b/Zend/tests/type_declarations/typed_properties_102.phpt
@@ -0,0 +1,22 @@
+--TEST--
+Compound assignment operator on static property holding ref
+--FILE--
+<?php declare(strict_types=1);
+
+class Test {
+    public static int $intProp = 123;
+    public static $prop;
+}
+
+Test::$prop =& Test::$intProp;
+try {
+    Test::$prop .= "foobar";
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+var_dump(Test::$prop, Test::$intProp);
+?>
+--EXPECT--
+Cannot assign string to reference held by property Test::$intProp of type int
+int(123)
+int(123)

diff --git a/Zend/tests/type_declarations/types_in_ast.phpt b/Zend/tests/type_declarations/types_in_ast.phpt
new file mode 100644 (file)
index 0000000..54619c2
--- /dev/null
+++ b/Zend/tests/type_declarations/types_in_ast.phpt
@@ -0,0 +1,23 @@
+--TEST--
+AST pretty-printer
+--INI--
+zend.assertions=1
+assert.exception=0
+--FILE--
+<?php
+assert(0 && ($a = function (int $a, ?int $b, int $c = null): ?int {
+       $x = new class {
+               public $a;
+               public int $b;
+               public ?int $c;
+       };
+}));
+?>
+--EXPECTF--
+Warning: assert(): assert(0 && ($a = function (int $a, ?int $b, int $c = null): ?int {
+    $x = new class {
+        public $a;
+        public int $b;
+        public ?int $c;
+    };
+})) failed in %stypes_in_ast.php on line 2

diff --git a/Zend/zend.c b/Zend/zend.c
index 3143217b8d0160a0e559cbf3dfce9ea10f999e5b..3619a7808d22eace08de545d7534c4225e3cfc0d 100644 (file)
--- a/Zend/zend.c
+++ b/Zend/zend.c
@@ -950,6 +950,28 @@ void zend_register_standard_ini_entries(void) /* {{{ */
 }
 /* }}} */
 
+static void zend_resolve_property_types(void) /* {{{ */
+{
+       zend_class_entry *ce;
+       zend_property_info *prop_info;
+
+       ZEND_HASH_FOREACH_PTR(CG(class_table), ce) {
+               if (UNEXPECTED(ce->type == ZEND_INTERNAL_CLASS && ZEND_CLASS_HAS_TYPE_HINTS(ce))) {
+                       ZEND_HASH_FOREACH_PTR(&ce->properties_info, prop_info) {
+                               if (ZEND_TYPE_IS_NAME(prop_info->type)) {
+                                       zend_string *type_name = zend_string_tolower(ZEND_TYPE_NAME(prop_info->type));
+                                       zend_class_entry *prop_ce = zend_hash_find_ptr(CG(class_table), type_name);
+
+                                       ZEND_ASSERT(prop_ce && prop_ce->type == ZEND_INTERNAL_CLASS);
+                                       prop_info->type = ZEND_TYPE_ENCODE_CE(prop_ce, ZEND_TYPE_ALLOW_NULL(prop_info->type));
+                                       zend_string_release(type_name);
+                               }
+                       } ZEND_HASH_FOREACH_END();
+               }
+       } ZEND_HASH_FOREACH_END();
+}
+/* }}} */
+
 /* Unlink the global (r/o) copies of the class, function and constant tables,
  * and use a fresh r/w copy for the startup thread
  */
@@ -971,6 +993,8 @@ int zend_post_startup(void) /* {{{ */
                }
        }
 
+       zend_resolve_property_types();
+
 #ifdef ZTS
        *GLOBAL_FUNCTION_TABLE = *compiler_globals->function_table;
        *GLOBAL_CLASS_TABLE = *compiler_globals->class_table;

diff --git a/Zend/zend.h b/Zend/zend.h
index aadda0c3cc875ac5cb2e68dea980a29b80e6730b..5918691c279b75d1be5989424e531be2d8d5c513 100644 (file)
--- a/Zend/zend.h
+++ b/Zend/zend.h
@@ -133,6 +133,8 @@ struct _zend_class_entry {
        HashTable properties_info;
        HashTable constants_table;
 
+       struct _zend_property_info **properties_info_table;
+
        zend_function *constructor;
        zend_function *destructor;
        zend_function *clone;

diff --git a/Zend/zend_API.c b/Zend/zend_API.c
index 02b89be61b15fa6f9a47e2fec260d81678cf195e..3154f4808f240b161f20f38c2e4295c299165b20 100644 (file)
--- a/Zend/zend_API.c
+++ b/Zend/zend_API.c
@@ -1173,7 +1173,21 @@ ZEND_API int zend_update_class_constants(zend_class_entry *class_type) /* {{{ */
                                                val = (zval*)((char*)class_type->default_properties_table + prop_info->offset - OBJ_PROP_TO_OFFSET(0));
                                        }
                                        if (Z_TYPE_P(val) == IS_CONSTANT_AST) {
-                                               if (UNEXPECTED(zval_update_constant_ex(val, ce) != SUCCESS)) {
+                                               if (prop_info->type) {
+                                                       zval tmp;
+
+                                                       ZVAL_COPY(&tmp, val);
+                                                       if (UNEXPECTED(zval_update_constant_ex(&tmp, ce) != SUCCESS)) {
+                                                               return FAILURE;
+                                                       }
+                                                       /* property initializers must always be evaluated with strict types */;
+                                                       if (UNEXPECTED(!zend_verify_property_type(prop_info, &tmp, /* strict */ 1))) {
+                                                               zval_ptr_dtor(&tmp);
+                                                               return FAILURE;
+                                                       }
+                                                       zval_ptr_dtor(val);
+                                                       ZVAL_COPY_VALUE(val, &tmp);
+                                               } else if (UNEXPECTED(zval_update_constant_ex(val, ce) != SUCCESS)) {
                                                        return FAILURE;
                                                }
                                        }
@@ -1234,7 +1248,18 @@ ZEND_API void object_properties_init_ex(zend_object *object, HashTable *properti
                            property_info &&
                            (property_info->flags & ZEND_ACC_STATIC) == 0) {
                                zval *slot = OBJ_PROP(object, property_info->offset);
-                               ZVAL_COPY_VALUE(slot, prop);
+
+                               if (UNEXPECTED(property_info->type)) {
+                                       zval tmp;
+
+                                       ZVAL_COPY_VALUE(&tmp, prop);
+                                       if (UNEXPECTED(!zend_verify_property_type(property_info, &tmp, 0))) {
+                                               continue;
+                                       }
+                                       ZVAL_COPY_VALUE(slot, &tmp);
+                               } else {
+                                       ZVAL_COPY_VALUE(slot, prop);
+                               }
                                ZVAL_INDIRECT(prop, slot);
                        }
                } ZEND_HASH_FOREACH_END();
@@ -2632,6 +2657,7 @@ ZEND_API zend_class_entry *zend_register_internal_class_ex(zend_class_entry *cla
 
        if (parent_ce) {
                zend_do_inheritance(register_class, parent_ce);
+               zend_build_properties_info_table(register_class);
        }
        return register_class;
 }
@@ -3556,10 +3582,14 @@ static inline zend_string *zval_make_interned_string(zval *zv) /* {{{ */
        return Z_STR_P(zv);
 }
 
-ZEND_API int zend_declare_property_ex(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment) /* {{{ */
+ZEND_API int zend_declare_typed_property(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment, zend_type type) /* {{{ */
 {
        zend_property_info *property_info, *property_info_ptr;
 
+       if (ZEND_TYPE_IS_SET(type)) {
+               ce->ce_flags |= ZEND_ACC_HAS_TYPE_HINTS;
+       }
+
        if (ce->type == ZEND_INTERNAL_CLASS) {
                property_info = pemalloc(sizeof(zend_property_info), 1);
        } else {
@@ -3602,10 +3632,20 @@ ZEND_API int zend_declare_property_ex(zend_class_entry *ce, zend_string *name, z
                        property_info->offset = property_info_ptr->offset;
                        zval_ptr_dtor(&ce->default_properties_table[OBJ_PROP_TO_NUM(property_info->offset)]);
                        zend_hash_del(&ce->properties_info, name);
+
+                       ZEND_ASSERT(ce->type == ZEND_INTERNAL_CLASS);
+                       ZEND_ASSERT(ce->properties_info_table != NULL);
+                       ce->properties_info_table[OBJ_PROP_TO_NUM(property_info->offset)] = property_info;
                } else {
                        property_info->offset = OBJ_PROP_TO_OFFSET(ce->default_properties_count);
                        ce->default_properties_count++;
                        ce->default_properties_table = perealloc(ce->default_properties_table, sizeof(zval) * ce->default_properties_count, ce->type == ZEND_INTERNAL_CLASS);
+
+                       /* For user classes this is handled during linking */
+                       if (ce->type == ZEND_INTERNAL_CLASS) {
+                               ce->properties_info_table = perealloc(ce->properties_info_table, sizeof(zend_property_info *) * ce->default_properties_count, 1);
+                               ce->properties_info_table[ce->default_properties_count - 1] = property_info;
+                       }
                }
                ZVAL_COPY_VALUE(&ce->default_properties_table[OBJ_PROP_TO_NUM(property_info->offset)], property);
        }
@@ -3637,12 +3677,20 @@ ZEND_API int zend_declare_property_ex(zend_class_entry *ce, zend_string *name, z
        property_info->flags = access_type;
        property_info->doc_comment = doc_comment;
        property_info->ce = ce;
+       property_info->type = type;
+
        zend_hash_update_ptr(&ce->properties_info, name, property_info);
 
        return SUCCESS;
 }
 /* }}} */
 
+ZEND_API int zend_declare_property_ex(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment) /* {{{ */
+{
+       return zend_declare_typed_property(ce, name, property, access_type, doc_comment, 0);
+}
+/* }}} */
+
 ZEND_API int zend_declare_property(zend_class_entry *ce, const char *name, size_t name_length, zval *property, int access_type) /* {{{ */
 {
        zend_string *key = zend_string_init(name, name_length, ce->type & ZEND_INTERNAL_CLASS);
@@ -3926,25 +3974,30 @@ ZEND_API void zend_update_property_stringl(zend_class_entry *scope, zval *object
 
 ZEND_API int zend_update_static_property_ex(zend_class_entry *scope, zend_string *name, zval *value) /* {{{ */
 {
-       zval *property;
+       zval *property, tmp;
+       zend_property_info *prop_info;
        zend_class_entry *old_scope = EG(fake_scope);
 
        EG(fake_scope) = scope;
-       property = zend_std_get_static_property(scope, name, 0);
+       property = zend_std_get_static_property_with_info(scope, name, BP_VAR_W, &prop_info);
        EG(fake_scope) = old_scope;
 
        if (!property) {
                return FAILURE;
        }
 
-       if (property != value) {
-               zval garbage;
-               ZVAL_DEREF(property);
-               ZVAL_DEREF(value);
-               ZVAL_COPY_VALUE(&garbage, property);
-               ZVAL_COPY(property, value);
-               zval_ptr_dtor(&garbage);
+       ZEND_ASSERT(!Z_ISREF_P(value));
+       Z_TRY_ADDREF_P(value);
+       if (prop_info->type) {
+               ZVAL_COPY_VALUE(&tmp, value);
+               if (!zend_verify_property_type(prop_info, &tmp, /* strict */ 0)) {
+                       Z_TRY_DELREF_P(value);
+                       return FAILURE;
+               }
+               value = &tmp;
        }
+
+       zend_assign_to_variable(property, value, IS_TMP_VAR, /* strict */ 0);
        return SUCCESS;
 }
 /* }}} */
@@ -4047,7 +4100,7 @@ ZEND_API zval *zend_read_static_property_ex(zend_class_entry *scope, zend_string
        zend_class_entry *old_scope = EG(fake_scope);
 
        EG(fake_scope) = scope;
-       property = zend_std_get_static_property(scope, name, silent);
+       property = zend_std_get_static_property(scope, name, silent ? BP_VAR_IS : BP_VAR_R);
        EG(fake_scope) = old_scope;
 
        return property;

diff --git a/Zend/zend_API.h b/Zend/zend_API.h
index 2357a1a49d94854af7834037498da467eafd49ac..27fc6cb011debe02b1f1aa1a770cae581d0e1f68 100644 (file)
--- a/Zend/zend_API.h
+++ b/Zend/zend_API.h
@@ -309,6 +309,9 @@ ZEND_API zend_bool zend_is_callable(zval *callable, uint32_t check_flags, zend_s
 ZEND_API zend_bool zend_make_callable(zval *callable, zend_string **callable_name);
 ZEND_API const char *zend_get_module_version(const char *module_name);
 ZEND_API int zend_get_module_started(const char *module_name);
+
+ZEND_API int zend_declare_typed_property(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment, zend_type type);
+
 ZEND_API int zend_declare_property_ex(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment);
 ZEND_API int zend_declare_property(zend_class_entry *ce, const char *name, size_t name_length, zval *property, int access_type);
 ZEND_API int zend_declare_property_null(zend_class_entry *ce, const char *name, size_t name_length, int access_type);
@@ -653,6 +656,134 @@ END_EXTERN_C()
 #define ZEND_GINIT_FUNCTION                    ZEND_MODULE_GLOBALS_CTOR_D
 #define ZEND_GSHUTDOWN_FUNCTION                ZEND_MODULE_GLOBALS_DTOR_D
 
+/* May modify arg in-place. Will free arg in failure case (and take ownership in success case).
+ * Prefer using the ZEND_TRY_ASSIGN_* macros over these APIs. */
+static zend_always_inline int zend_try_assign_ex(zval *zv, zval *arg, zend_bool strict) {
+       if (EXPECTED(Z_ISREF_P(zv))) {
+               zend_reference *ref = Z_REF_P(zv);
+               zv = Z_REFVAL_P(zv);
+               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref)) &&
+                       UNEXPECTED(!zend_verify_ref_assignable_zval(ref, arg, strict))
+               ) {
+                       zval_ptr_dtor(arg);
+                       return FAILURE;
+               }
+       }
+
+       zval_ptr_dtor(zv);
+       ZVAL_COPY_VALUE(zv, arg);
+       return SUCCESS;
+} 
+
+static zend_always_inline int zend_try_assign(zval *zv, zval *arg) {
+       return zend_try_assign_ex(zv, arg, ZEND_ARG_USES_STRICT_TYPES());
+}
+
+#define ZEND_TRY_ASSIGN_NULL(zv) do { \
+       zval _zv; \
+       ZVAL_NULL(&_zv); \
+       zend_try_assign(zv, &_zv); \
+} while (0)
+
+#define ZEND_TRY_ASSIGN_FALSE(zv) do { \
+       zval _zv; \
+       ZVAL_FALSE(&_zv); \
+       zend_try_assign(zv, &_zv); \
+} while (0)
+
+#define ZEND_TRY_ASSIGN_TRUE(zv) do { \
+       zval _zv; \
+       ZVAL_TRUE(&_zv); \
+       zend_try_assign(zv, &_zv); \
+} while (0)
+
+#define ZEND_TRY_ASSIGN_LONG(zv, lval) do { \
+       zval _zv; \
+       ZVAL_LONG(&_zv, lval); \
+       zend_try_assign(zv, &_zv); \
+} while (0)
+
+#define ZEND_TRY_ASSIGN_DOUBLE(zv, dval) do { \
+       zval _zv; \
+       ZVAL_DOUBLE(&_zv, dval); \
+       zend_try_assign(zv, &_zv); \
+} while (0)
+
+#define ZEND_TRY_ASSIGN_EMPTY_STRING(zv) do { \
+       zval _zv; \
+       ZVAL_EMPTY_STRING(&_zv); \
+       zend_try_assign(zv, &_zv); \
+} while (0)
+
+#define ZEND_TRY_ASSIGN_STR(zv, str) do { \
+       zval _zv; \
+       ZVAL_STR(&_zv, str); \
+       zend_try_assign(zv, &_zv); \
+} while (0)
+
+#define ZEND_TRY_ASSIGN_NEW_STR(zv, str) do { \
+       zval _zv; \
+       ZVAL_NEW_STR(&_zv, str); \
+       zend_try_assign(zv, &_zv); \
+} while (0)
+
+#define ZEND_TRY_ASSIGN_STRING(zv, string) do { \
+       zval _zv; \
+       ZVAL_STRING(&_zv, string); \
+       zend_try_assign(zv, &_zv); \
+} while (0)
+
+#define ZEND_TRY_ASSIGN_STRINGL(zv, string, len) do { \
+       zval _zv; \
+       ZVAL_STRINGL(&_zv, string, len); \
+       zend_try_assign(zv, &_zv); \
+} while (0)
+
+#define ZEND_TRY_ASSIGN_RES(zv, res) do { \
+       zval _zv; \
+       ZVAL_RES(&_zv, res); \
+       zend_try_assign(zv, &_zv); \
+} while (0)
+
+#define ZEND_TRY_ASSIGN_VALUE_EX(zv, other_zv, strict) do { \
+       zval _zv; \
+       ZVAL_COPY_VALUE(&_zv, other_zv); \
+       zend_try_assign_ex(zv, &_zv, strict); \
+} while (0)
+
+#define ZEND_TRY_ASSIGN_COPY_EX(zv, other_zv, strict) do { \
+       zval _zv; \
+       ZVAL_COPY(&_zv, other_zv); \
+       zend_try_assign_ex(zv, &_zv, strict); \
+} while (0)
+
+#define ZEND_TRY_ASSIGN_VALUE(zv, other_zv) \
+       ZEND_TRY_ASSIGN_VALUE_EX(zv, other_zv, ZEND_ARG_USES_STRICT_TYPES())
+#define ZEND_TRY_ASSIGN_COPY(zv, other_zv) \
+       ZEND_TRY_ASSIGN_COPY_EX(zv, other_zv, ZEND_ARG_USES_STRICT_TYPES())
+
+/* Initializes a reference to an empty array and returns dereferenced zval,
+ * or NULL if the initialization failed. */
+static zend_always_inline zval *zend_try_array_init(zval *zv) {
+       zval tmp;
+       ZVAL_ARR(&tmp, zend_new_array(0));
+       if (UNEXPECTED(zend_try_assign(zv, &tmp) == FAILURE)) {
+               return NULL;
+       }
+       ZVAL_DEREF(zv);
+       return zv;
+}
+
+static zend_always_inline zval *zend_try_array_init_size(zval *zv, size_t size) {
+       zval tmp;
+       ZVAL_ARR(&tmp, zend_new_array(size));
+       if (UNEXPECTED(zend_try_assign(zv, &tmp) == FAILURE)) {
+               return NULL;
+       }
+       ZVAL_DEREF(zv);
+       return zv;
+}
+
 /* Fast parameter parsing API */
 
 /* Fast ZPP is always enabled now; this define is left in for compatibility

diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c
index 08fde1d1b09e05c944e033d144044bab61f4537b..8ddf8ea9abc55dd83763be24928f690deb6c7f8f 100644 (file)
--- a/Zend/zend_ast.c
+++ b/Zend/zend_ast.c
@@ -1442,7 +1442,10 @@ simple_list:
                        zend_ast_export_var_list(str, (zend_ast_list*)ast, indent);
                        smart_str_appendc(str, ')');
                        break;
-               case ZEND_AST_PROP_DECL:
+               case ZEND_AST_PROP_GROUP: {
+                       zend_ast *type_ast = ast->child[0];
+                       zend_ast *prop_ast = ast->child[1];
+
                        if (ast->attr & ZEND_ACC_PUBLIC) {
                                smart_str_appends(str, "public ");
                        } else if (ast->attr & ZEND_ACC_PROTECTED) {
@@ -1453,7 +1456,20 @@ simple_list:
                        if (ast->attr & ZEND_ACC_STATIC) {
                                smart_str_appends(str, "static ");
                        }
+
+                       if (type_ast) {
+                               if (type_ast->attr & ZEND_TYPE_NULLABLE) {
+                                       smart_str_appendc(str, '?');
+                               }
+                               zend_ast_export_ns_name(
+                                       str, type_ast, 0, indent);
+                               smart_str_appendc(str, ' ');
+                       }
+
+                       ast = prop_ast;
                        goto simple_list;
+               }
+
                case ZEND_AST_CONST_DECL:
                case ZEND_AST_CLASS_CONST_DECL:
                        smart_str_appends(str, "const ");

diff --git a/Zend/zend_ast.h b/Zend/zend_ast.h
index 008d5b19ebcef236170f7da4069982bb6bd3c046..9600b801ca0f5eaaf7e35836bf2a897b6ec04bf7 100644 (file)
--- a/Zend/zend_ast.h
+++ b/Zend/zend_ast.h
@@ -135,6 +135,7 @@ enum _zend_ast_kind {
        ZEND_AST_USE_ELEM,
        ZEND_AST_TRAIT_ALIAS,
        ZEND_AST_GROUP_USE,
+       ZEND_AST_PROP_GROUP,
 
        /* 3 child nodes */
        ZEND_AST_METHOD_CALL = 3 << ZEND_AST_NUM_CHILDREN_SHIFT,

diff --git a/Zend/zend_closures.c b/Zend/zend_closures.c
index 12aec3916e80934588da1d9700e1614a63626521..c3dbf145e995d387095f75a44c141e33acfc128b 100644 (file)
--- a/Zend/zend_closures.c
+++ b/Zend/zend_closures.c
@@ -325,10 +325,10 @@ ZEND_METHOD(Closure, fromCallable)
 
        if (success == FAILURE || error) {
                if (error) {
-                       zend_throw_exception_ex(zend_ce_type_error, 0, "Failed to create closure from callable: %s", error);
+                       zend_type_error("Failed to create closure from callable: %s", error);
                        efree(error);
                } else {
-                       zend_throw_exception_ex(zend_ce_type_error, 0, "Failed to create closure from callable");
+                       zend_type_error("Failed to create closure from callable");
                }
        }
 }
@@ -406,9 +406,10 @@ static zval *zend_closure_read_property(zval *object, zval *member, int type, vo
 }
 /* }}} */
 
-static void zend_closure_write_property(zval *object, zval *member, zval *value, void **cache_slot) /* {{{ */
+static zval *zend_closure_write_property(zval *object, zval *member, zval *value, void **cache_slot) /* {{{ */
 {
        ZEND_CLOSURE_PROPERTY_ERROR();
+       return value;
 }
 /* }}} */
 

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index c5c9f1f475432275efd5bf2acb5f2a4023d0dfd1..7210cb4babb33fae22b0e14988e8bb6eba5da01b 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -62,20 +62,15 @@ typedef struct _zend_loop_var {
        } u;
 } zend_loop_var;
 
-static inline uint32_t zend_alloc_cache_slot(void) {
+static inline uint32_t zend_alloc_cache_slots(unsigned count) {
        zend_op_array *op_array = CG(active_op_array);
        uint32_t ret = op_array->cache_size;
-       op_array->cache_size += sizeof(void*);
+       op_array->cache_size += count * sizeof(void*);
        return ret;
 }
 
-#define POLYMORPHIC_CACHE_SLOT_SIZE 2
-
-static inline uint32_t zend_alloc_polymorphic_cache_slot(void) {
-       zend_op_array *op_array = CG(active_op_array);
-       uint32_t ret = op_array->cache_size;
-       op_array->cache_size += POLYMORPHIC_CACHE_SLOT_SIZE * sizeof(void*);
-       return ret;
+static inline uint32_t zend_alloc_cache_slot(void) {
+       return zend_alloc_cache_slots(1);
 }
 
 ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type);
@@ -1605,6 +1600,7 @@ ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify
 
        ce->default_properties_count = 0;
        ce->default_static_members_count = 0;
+       ce->properties_info_table = NULL;
 
        if (nullify_handlers) {
                ce->constructor = NULL;
@@ -2475,7 +2471,7 @@ static zend_bool is_this_fetch(zend_ast *ast) /* {{{ */
 }
 /* }}} */
 
-static void zend_compile_simple_var(znode *result, zend_ast *ast, uint32_t type, int delayed) /* {{{ */
+static zend_op *zend_compile_simple_var(znode *result, zend_ast *ast, uint32_t type, int delayed) /* {{{ */
 {
        if (is_this_fetch(ast)) {
                zend_op *opline = zend_emit_op(result, ZEND_FETCH_THIS, NULL, NULL);
@@ -2483,9 +2479,11 @@ static void zend_compile_simple_var(znode *result, zend_ast *ast, uint32_t type,
                        opline->result_type = IS_TMP_VAR;
                        result->op_type = IS_TMP_VAR;
                }
+               return opline;
        } else if (zend_try_compile_cv(result, ast) == FAILURE) {
-               zend_compile_simple_var_no_cv(result, ast, type, delayed);
+               return zend_compile_simple_var_no_cv(result, ast, type, delayed);
        }
+       return NULL;
 }
 /* }}} */
 
@@ -2503,7 +2501,7 @@ static void zend_separate_if_call_and_write(znode *node, zend_ast *ast, uint32_t
 }
 /* }}} */
 
-void zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t type);
+zend_op *zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t type, zend_bool by_ref);
 void zend_compile_assign(znode *result, zend_ast *ast);
 
 static inline void zend_emit_assign_znode(zend_ast *var_ast, znode *value_node) /* {{{ */
@@ -2524,7 +2522,11 @@ static zend_op *zend_delayed_compile_dim(znode *result, zend_ast *ast, uint32_t
 
        znode var_node, dim_node;
 
-       zend_delayed_compile_var(&var_node, var_ast, type);
+       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;
+       }
+
        zend_separate_if_call_and_write(&var_node, var_ast, type);
 
        if (dim_ast == NULL) {
@@ -2568,7 +2570,11 @@ static zend_op *zend_delayed_compile_prop(znode *result, zend_ast *ast, uint32_t
        if (is_this_fetch(obj_ast)) {
                obj_node.op_type = IS_UNUSED;
        } else {
-               zend_delayed_compile_var(&obj_node, obj_ast, type);
+               opline = zend_delayed_compile_var(&obj_node, obj_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_OBJ_WRITE;
+               }
+
                zend_separate_if_call_and_write(&obj_node, obj_ast, type);
        }
        zend_compile_expr(&prop_node, prop_ast);
@@ -2576,7 +2582,7 @@ static zend_op *zend_delayed_compile_prop(znode *result, zend_ast *ast, uint32_t
        opline = zend_delayed_emit_op(result, ZEND_FETCH_OBJ_R, &obj_node, &prop_node);
        if (opline->op2_type == IS_CONST) {
                convert_to_string(CT_CONSTANT(opline->op2));
-               opline->extended_value = zend_alloc_polymorphic_cache_slot();
+               opline->extended_value = zend_alloc_cache_slots(3);
        }
 
        zend_adjust_for_fetch_type(opline, result, type);
@@ -2584,15 +2590,18 @@ static zend_op *zend_delayed_compile_prop(znode *result, zend_ast *ast, uint32_t
 }
 /* }}} */
 
-static zend_op *zend_compile_prop(znode *result, zend_ast *ast, uint32_t type) /* {{{ */
+static zend_op *zend_compile_prop(znode *result, zend_ast *ast, uint32_t type, int by_ref) /* {{{ */
 {
        uint32_t offset = zend_delayed_compile_begin();
-       zend_delayed_compile_prop(result, ast, type);
+       zend_op *opline = zend_delayed_compile_prop(result, ast, type);
+       if (by_ref) { /* shared with cache_slot */
+               opline->extended_value |= ZEND_FETCH_REF;
+       }
        return zend_delayed_compile_end(offset);
 }
 /* }}} */
 
-zend_op *zend_compile_static_prop(znode *result, zend_ast *ast, uint32_t type, int delayed) /* {{{ */
+zend_op *zend_compile_static_prop(znode *result, zend_ast *ast, uint32_t type, int by_ref, int delayed) /* {{{ */
 {
        zend_ast *class_ast = ast->child[0];
        zend_ast *prop_ast = ast->child[1];
@@ -2611,7 +2620,7 @@ zend_op *zend_compile_static_prop(znode *result, zend_ast *ast, uint32_t type, i
        }
        if (opline->op1_type == IS_CONST) {
                convert_to_string(CT_CONSTANT(opline->op1));
-               opline->extended_value = zend_alloc_polymorphic_cache_slot();
+               opline->extended_value = zend_alloc_cache_slots(3);
        }
        if (class_node.op_type == IS_CONST) {
                opline->op2_type = IS_CONST;
@@ -2624,6 +2633,10 @@ zend_op *zend_compile_static_prop(znode *result, zend_ast *ast, uint32_t type, i
                SET_NODE(opline->op2, &class_node);
        }
 
+       if (by_ref && (type == BP_VAR_W || type == BP_VAR_FUNC_ARG)) { /* shared with cache_slot */
+               opline->extended_value |= ZEND_FETCH_REF;
+       }
+
        zend_adjust_for_fetch_type(opline, result, type);
        return opline;
 }
@@ -2854,13 +2867,22 @@ void zend_compile_assign(znode *result, zend_ast *ast) /* {{{ */
 
        switch (var_ast->kind) {
                case ZEND_AST_VAR:
-               case ZEND_AST_STATIC_PROP:
                        offset = zend_delayed_compile_begin();
-                       zend_delayed_compile_var(&var_node, var_ast, BP_VAR_W);
+                       zend_delayed_compile_var(&var_node, var_ast, BP_VAR_W, 0);
                        zend_compile_expr(&expr_node, expr_ast);
                        zend_delayed_compile_end(offset);
                        zend_emit_op(result, ZEND_ASSIGN, &var_node, &expr_node);
                        return;
+               case ZEND_AST_STATIC_PROP:
+                       offset = zend_delayed_compile_begin();
+                       zend_delayed_compile_var(result, var_ast, BP_VAR_W, 0);
+                       zend_compile_expr(&expr_node, expr_ast);
+
+                       opline = zend_delayed_compile_end(offset);
+                       opline->opcode = ZEND_ASSIGN_STATIC_PROP;
+
+                       zend_emit_op_data(&expr_node);
+                       return;
                case ZEND_AST_DIM:
                        offset = zend_delayed_compile_begin();
                        zend_delayed_compile_dim(result, var_ast, BP_VAR_W);
@@ -2901,7 +2923,7 @@ void zend_compile_assign(znode *result, zend_ast *ast) /* {{{ */
                                                "Cannot assign reference to non referencable value");
                                }
 
-                               zend_compile_var(&expr_node, expr_ast, BP_VAR_W);
+                               zend_compile_var(&expr_node, expr_ast, BP_VAR_W, 1);
                                /* MAKE_REF is usually not necessary for CVs. However, if there are
                                 * self-assignments, this forces the RHS to evaluate first. */
                                if (expr_node.op_type != IS_CV
@@ -2945,8 +2967,8 @@ void zend_compile_assign_ref(znode *result, zend_ast *ast) /* {{{ */
        zend_ensure_writable_variable(target_ast);
 
        offset = zend_delayed_compile_begin();
-       zend_delayed_compile_var(&target_node, target_ast, BP_VAR_W);
-       zend_compile_var(&source_node, source_ast, BP_VAR_W);
+       zend_delayed_compile_var(&target_node, target_ast, BP_VAR_W, 1);
+       zend_compile_var(&source_node, source_ast, BP_VAR_W, 1);
 
        if ((target_ast->kind != ZEND_AST_VAR
          || target_ast->child[0]->kind != ZEND_AST_ZVAL)
@@ -2960,16 +2982,33 @@ void zend_compile_assign_ref(znode *result, zend_ast *ast) /* {{{ */
                zend_emit_op(&source_node, ZEND_MAKE_REF, &source_node, NULL);
        }
 
-       zend_delayed_compile_end(offset);
+       opline = zend_delayed_compile_end(offset);
 
        if (source_node.op_type != IS_VAR && zend_is_call(source_ast)) {
                zend_error_noreturn(E_COMPILE_ERROR, "Cannot use result of built-in function in write context");
        }
 
-       opline = zend_emit_op(result, ZEND_ASSIGN_REF, &target_node, &source_node);
+       if (opline && opline->opcode == ZEND_FETCH_OBJ_W) {
+               opline->opcode = ZEND_ASSIGN_OBJ_REF;
+               opline->extended_value &= ~ZEND_FETCH_REF;
+               zend_emit_op_data(&source_node);
+               if (result != NULL) {
+                       *result = target_node;
+               }
+       } else if (opline && opline->opcode == ZEND_FETCH_STATIC_PROP_W) {
+               opline->opcode = ZEND_ASSIGN_STATIC_PROP_REF;
+               opline->extended_value &= ~ZEND_FETCH_REF;
+               zend_emit_op_data(&source_node);
+               if (result != NULL) {
+                       *result = target_node;
+               }
+       } else {
+               opline = zend_emit_op(result, ZEND_ASSIGN_REF, &target_node, &source_node);
+               opline->extended_value = 0;
+       }
 
        if (zend_is_call(source_ast)) {
-               opline->extended_value = ZEND_RETURNS_FUNCTION;
+               opline->extended_value |= ZEND_RETURNS_FUNCTION;
        }
 }
 /* }}} */
@@ -2996,13 +3035,25 @@ void zend_compile_compound_assign(znode *result, zend_ast *ast) /* {{{ */
 
        switch (var_ast->kind) {
                case ZEND_AST_VAR:
-               case ZEND_AST_STATIC_PROP:
                        offset = zend_delayed_compile_begin();
-                       zend_delayed_compile_var(&var_node, var_ast, BP_VAR_RW);
+                       zend_delayed_compile_var(&var_node, var_ast, BP_VAR_RW, 0);
                        zend_compile_expr(&expr_node, expr_ast);
                        zend_delayed_compile_end(offset);
                        zend_emit_op(result, opcode, &var_node, &expr_node);
                        return;
+               case ZEND_AST_STATIC_PROP:
+                       offset = zend_delayed_compile_begin();
+                       zend_delayed_compile_var(result, var_ast, BP_VAR_RW, 0);
+                       zend_compile_expr(&expr_node, expr_ast);
+
+                       opline = zend_delayed_compile_end(offset);
+                       cache_slot = opline->extended_value;
+                       opline->opcode = opcode;
+                       opline->extended_value = ZEND_ASSIGN_STATIC_PROP;
+
+                       opline = zend_emit_op_data(&expr_node);
+                       opline->extended_value = cache_slot;
+                       return;
                case ZEND_AST_DIM:
                        offset = zend_delayed_compile_begin();
                        zend_delayed_compile_dim(result, var_ast, BP_VAR_RW);
@@ -3012,7 +3063,7 @@ void zend_compile_compound_assign(znode *result, zend_ast *ast) /* {{{ */
                        opline->opcode = opcode;
                        opline->extended_value = ZEND_ASSIGN_DIM;
 
-                       opline = zend_emit_op_data(&expr_node);
+                       zend_emit_op_data(&expr_node);
                        return;
                case ZEND_AST_PROP:
                        offset = zend_delayed_compile_begin();
@@ -3066,7 +3117,7 @@ uint32_t zend_compile_args(zend_ast *ast, zend_function *fbc) /* {{{ */
                arg_count++;
                if (zend_is_variable(arg)) {
                        if (zend_is_call(arg)) {
-                               zend_compile_var(&arg_node, arg, BP_VAR_R);
+                               zend_compile_var(&arg_node, arg, BP_VAR_R, 0);
                                if (arg_node.op_type & (IS_CONST|IS_TMP_VAR)) {
                                        /* Function call was converted into builtin instruction */
                                        opcode = ZEND_SEND_VAL;
@@ -3085,10 +3136,10 @@ uint32_t zend_compile_args(zend_ast *ast, zend_function *fbc) /* {{{ */
                                }
                        } else if (fbc) {
                                if (ARG_SHOULD_BE_SENT_BY_REF(fbc, arg_num)) {
-                                       zend_compile_var(&arg_node, arg, BP_VAR_W);
+                                       zend_compile_var(&arg_node, arg, BP_VAR_W, 1);
                                        opcode = ZEND_SEND_REF;
                                } else {
-                                       zend_compile_var(&arg_node, arg, BP_VAR_R);
+                                       zend_compile_var(&arg_node, arg, BP_VAR_R, 0);
                                        opcode = (arg_node.op_type == IS_TMP_VAR) ? ZEND_SEND_VAL : ZEND_SEND_VAR;
                                }
                        } else {
@@ -3106,7 +3157,7 @@ uint32_t zend_compile_args(zend_ast *ast, zend_function *fbc) /* {{{ */
                                        }
                                        opline = zend_emit_op(NULL, ZEND_CHECK_FUNC_ARG, NULL, NULL);
                                        opline->op2.num = arg_num;
-                                       zend_compile_var(&arg_node, arg, BP_VAR_FUNC_ARG);
+                                       zend_compile_var(&arg_node, arg, BP_VAR_FUNC_ARG, 1);
                                        opcode = ZEND_SEND_FUNC_ARG;
                                } while (0);
                        }
@@ -3250,7 +3301,7 @@ void zend_compile_dynamic_call(znode *result, znode *name_node, zend_ast *args_a
                        opline->op2_type = IS_CONST;
                        opline->op2.constant = zend_add_func_name_literal(method);
                        /* 2 slots, for class and method */
-                       opline->result.num = zend_alloc_polymorphic_cache_slot();
+                       opline->result.num = zend_alloc_cache_slots(2);
                        zval_ptr_dtor(&name_node->u.constant);
                } else {
                        zend_op *opline = get_next_op();
@@ -3980,7 +4031,7 @@ void zend_compile_method_call(znode *result, zend_ast *ast, uint32_t type) /* {{
                opline->op2_type = IS_CONST;
                opline->op2.constant = zend_add_func_name_literal(
                        Z_STR(method_node.u.constant));
-               opline->result.num = zend_alloc_polymorphic_cache_slot();
+               opline->result.num = zend_alloc_cache_slots(2);
        } else {
                SET_NODE(opline->op2, &method_node);
        }
@@ -4041,7 +4092,7 @@ void zend_compile_static_call(znode *result, zend_ast *ast, uint32_t type) /* {{
                opline->op2_type = IS_CONST;
                opline->op2.constant = zend_add_func_name_literal(
                        Z_STR(method_node.u.constant));
-               opline->result.num = zend_alloc_polymorphic_cache_slot();
+               opline->result.num = zend_alloc_cache_slots(2);
        } else {
                if (opline->op1_type == IS_CONST) {
                        opline->result.num = zend_alloc_cache_slot();
@@ -4239,11 +4290,11 @@ void zend_compile_unset(zend_ast *ast) /* {{{ */
                        opline->opcode = ZEND_UNSET_DIM;
                        return;
                case ZEND_AST_PROP:
-                       opline = zend_compile_prop(NULL, var_ast, BP_VAR_UNSET);
+                       opline = zend_compile_prop(NULL, var_ast, BP_VAR_UNSET, 0);
                        opline->opcode = ZEND_UNSET_OBJ;
                        return;
                case ZEND_AST_STATIC_PROP:
-                       opline = zend_compile_static_prop(NULL, var_ast, BP_VAR_UNSET, 0);
+                       opline = zend_compile_static_prop(NULL, var_ast, BP_VAR_UNSET, 0, 0);
                        opline->opcode = ZEND_UNSET_STATIC_PROP;
                        return;
                EMPTY_SWITCH_DEFAULT_CASE()
@@ -4356,7 +4407,7 @@ void zend_compile_return(zend_ast *ast) /* {{{ */
                expr_node.op_type = IS_CONST;
                ZVAL_NULL(&expr_node.u.constant);
        } else if (by_ref && zend_is_variable(expr_ast) && !zend_is_call(expr_ast)) {
-               zend_compile_var(&expr_node, expr_ast, BP_VAR_W);
+               zend_compile_var(&expr_node, expr_ast, BP_VAR_W, 1);
        } else {
                zend_compile_expr(&expr_node, expr_ast);
        }
@@ -4714,7 +4765,7 @@ void zend_compile_foreach(zend_ast *ast) /* {{{ */
        }
 
        if (by_ref && is_variable) {
-               zend_compile_var(&expr_node, expr_ast, BP_VAR_W);
+               zend_compile_var(&expr_node, expr_ast, BP_VAR_W, 1);
        } else {
                zend_compile_expr(&expr_node, expr_ast);
        }
@@ -5979,10 +6030,9 @@ void zend_compile_func_decl(znode *result, zend_ast *ast, zend_bool toplevel) /*
 }
 /* }}} */
 
-void zend_compile_prop_decl(zend_ast *ast) /* {{{ */
+void zend_compile_prop_decl(zend_ast *ast, zend_ast *type_ast, uint32_t flags) /* {{{ */
 {
        zend_ast_list *list = zend_ast_get_list(ast);
-       uint32_t flags = list->attr;
        zend_class_entry *ce = CG(active_class_entry);
        uint32_t i, children = list->children;
 
@@ -6002,6 +6052,19 @@ void zend_compile_prop_decl(zend_ast *ast) /* {{{ */
                zend_string *name = zval_make_interned_string(zend_ast_get_zval(name_ast));
                zend_string *doc_comment = NULL;
                zval value_zv;
+               zend_type type = 0;
+
+               if (type_ast) {
+                       type = zend_compile_typename(type_ast, 0);
+
+                       if (ZEND_TYPE_CODE(type) == IS_VOID || ZEND_TYPE_CODE(type) == IS_CALLABLE) {
+                               zend_error_noreturn(E_COMPILE_ERROR,
+                                       "Property %s::$%s cannot have type %s",
+                                       ZSTR_VAL(ce->name),
+                                       ZSTR_VAL(name),
+                                       zend_get_type_by_const(ZEND_TYPE_CODE(type)));
+                       }
+               }
 
                /* Doc comment has been appended as last element in ZEND_AST_PROP_ELEM ast */
                if (doc_comment_ast) {
@@ -6021,15 +6084,58 @@ void zend_compile_prop_decl(zend_ast *ast) /* {{{ */
 
                if (value_ast) {
                        zend_const_expr_to_zval(&value_zv, value_ast);
-               } else {
+
+                       if (ZEND_TYPE_IS_SET(type) && !Z_CONSTANT(value_zv)) {
+                               if (Z_TYPE(value_zv) == IS_NULL) {
+                                       if (!ZEND_TYPE_ALLOW_NULL(type)) {
+                                               const char *name = ZEND_TYPE_IS_CLASS(type)
+                                                       ? ZSTR_VAL(ZEND_TYPE_NAME(type)) : zend_get_type_by_const(ZEND_TYPE_CODE(type));
+                                               zend_error_noreturn(E_COMPILE_ERROR,
+                                                               "Default value for property of type %s may not be null. "
+                                                               "Use the nullable type ?%s to allow null default value",
+                                                               name, name);
+                                       }
+                               } else if (ZEND_TYPE_IS_CLASS(type)) {
+                                       zend_error_noreturn(E_COMPILE_ERROR,
+                                                       "Property of type %s may not have default value", ZSTR_VAL(ZEND_TYPE_NAME(type)));
+                               } else if (ZEND_TYPE_CODE(type) == IS_ARRAY || ZEND_TYPE_CODE(type) == IS_ITERABLE) {
+                                       if (Z_TYPE(value_zv) != IS_ARRAY) {
+                                               zend_error_noreturn(E_COMPILE_ERROR,
+                                                               "Default value for property of type %s can only be an array",
+                                                               zend_get_type_by_const(ZEND_TYPE_CODE(type)));
+                                       }
+                               } else if (ZEND_TYPE_CODE(type) == IS_DOUBLE) {
+                                       if (Z_TYPE(value_zv) != IS_DOUBLE && Z_TYPE(value_zv) != IS_LONG) {
+                                               zend_error_noreturn(E_COMPILE_ERROR,
+                                                               "Default value for property of type float can only be float or int");
+                                       }
+                               } else if (!ZEND_SAME_FAKE_TYPE(ZEND_TYPE_CODE(type), Z_TYPE(value_zv))) {
+                                       zend_error_noreturn(E_COMPILE_ERROR,
+                                                       "Default value for property of type %s can only be %s",
+                                                       zend_get_type_by_const(ZEND_TYPE_CODE(type)),
+                                                       zend_get_type_by_const(ZEND_TYPE_CODE(type)));
+                               }
+                       }
+               } else if (!ZEND_TYPE_IS_SET(type)) {
                        ZVAL_NULL(&value_zv);
+               } else {
+                       ZVAL_UNDEF(&value_zv);
                }
 
-               zend_declare_property_ex(ce, name, &value_zv, flags, doc_comment);
+               zend_declare_typed_property(ce, name, &value_zv, flags, doc_comment, type);
        }
 }
 /* }}} */
 
+void zend_compile_prop_group(zend_ast *list) /* {{{ */
+{
+       zend_ast *type_ast = list->child[0];
+       zend_ast *prop_ast = list->child[1];
+
+       zend_compile_prop_decl(prop_ast, type_ast, list->attr);
+}
+/* }}} */
+
 void zend_compile_class_const_decl(zend_ast *ast) /* {{{ */
 {
        zend_ast_list *list = zend_ast_get_list(ast);
@@ -6378,6 +6484,7 @@ void zend_compile_class_decl(zend_ast *ast, zend_bool toplevel) /* {{{ */
                                        CG(zend_lineno) = decl->end_lineno;
                                        ce->ce_flags |= ZEND_ACC_LINKED;
                                        zend_do_inheritance(ce, parent_ce);
+                                       zend_build_properties_info_table(ce);
                                        if ((ce->ce_flags & (ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_INTERFACE|ZEND_ACC_TRAIT|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) == ZEND_ACC_IMPLICIT_ABSTRACT_CLASS) {
                                                zend_verify_abstract_class(ce);
                                        }
@@ -6389,6 +6496,7 @@ void zend_compile_class_decl(zend_ast *ast, zend_bool toplevel) /* {{{ */
                } else {
                        if (EXPECTED(zend_hash_add_ptr(CG(class_table), lcname, ce) != NULL)) {
                                zend_string_release(lcname);
+                               zend_build_properties_info_table(ce);
                                ce->ce_flags |= ZEND_ACC_LINKED;
                                return;
                        }
@@ -7192,12 +7300,16 @@ void zend_compile_post_incdec(znode *result, zend_ast *ast) /* {{{ */
        zend_ensure_writable_variable(var_ast);
 
        if (var_ast->kind == ZEND_AST_PROP) {
-               zend_op *opline = zend_compile_prop(NULL, var_ast, BP_VAR_RW);
+               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);
+       } else if (var_ast->kind == ZEND_AST_STATIC_PROP) {
+               zend_op *opline = zend_compile_static_prop(NULL, var_ast, BP_VAR_RW, 0, 0);
+               opline->opcode = ast->kind == ZEND_AST_POST_INC ? ZEND_POST_INC_STATIC_PROP : ZEND_POST_DEC_STATIC_PROP;
+               zend_make_tmp_result(result, opline);
        } else {
                znode var_node;
-               zend_compile_var(&var_node, var_ast, BP_VAR_RW);
+               zend_compile_var(&var_node, var_ast, BP_VAR_RW, 0);
                zend_emit_op_tmp(result, ast->kind == ZEND_AST_POST_INC ? ZEND_POST_INC : ZEND_POST_DEC,
                        &var_node, NULL);
        }
@@ -7212,11 +7324,14 @@ void zend_compile_pre_incdec(znode *result, zend_ast *ast) /* {{{ */
        zend_ensure_writable_variable(var_ast);
 
        if (var_ast->kind == ZEND_AST_PROP) {
-               zend_op *opline = zend_compile_prop(result, var_ast, BP_VAR_RW);
+               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;
+       } else if (var_ast->kind == ZEND_AST_STATIC_PROP) {
+               zend_op *opline = zend_compile_static_prop(result, var_ast, BP_VAR_RW, 0, 0);
+               opline->opcode = ast->kind == ZEND_AST_PRE_INC ? ZEND_PRE_INC_STATIC_PROP : ZEND_PRE_DEC_STATIC_PROP;
        } else {
                znode var_node;
-               zend_compile_var(&var_node, var_ast, BP_VAR_RW);
+               zend_compile_var(&var_node, var_ast, BP_VAR_RW, 0);
                zend_emit_op(result, ast->kind == ZEND_AST_PRE_INC ? ZEND_PRE_INC : ZEND_PRE_DEC,
                        &var_node, NULL);
        }
@@ -7310,7 +7425,7 @@ void zend_compile_coalesce(znode *result, zend_ast *ast) /* {{{ */
        zend_op *opline;
        uint32_t opnum;
 
-       zend_compile_var(&expr_node, expr_ast, BP_VAR_IS);
+       zend_compile_var(&expr_node, expr_ast, BP_VAR_IS, 0);
 
        opnum = get_next_op_number();
        zend_emit_op_tmp(result, ZEND_COALESCE, &expr_node, NULL);
@@ -7377,7 +7492,7 @@ void zend_compile_yield(znode *result, zend_ast *ast) /* {{{ */
 
        if (value_ast) {
                if (returns_by_ref && zend_is_variable(value_ast) && !zend_is_call(value_ast)) {
-                       zend_compile_var(&value_node, value_ast, BP_VAR_W);
+                       zend_compile_var(&value_node, value_ast, BP_VAR_W, 1);
                } else {
                        zend_compile_expr(&value_node, value_ast);
                }
@@ -7495,11 +7610,11 @@ void zend_compile_isset_or_empty(znode *result, zend_ast *ast) /* {{{ */
                        opline->opcode = ZEND_ISSET_ISEMPTY_DIM_OBJ;
                        break;
                case ZEND_AST_PROP:
-                       opline = zend_compile_prop(result, var_ast, BP_VAR_IS);
+                       opline = zend_compile_prop(result, var_ast, BP_VAR_IS, 0);
                        opline->opcode = ZEND_ISSET_ISEMPTY_PROP_OBJ;
                        break;
                case ZEND_AST_STATIC_PROP:
-                       opline = zend_compile_static_prop(result, var_ast, BP_VAR_IS, 0);
+                       opline = zend_compile_static_prop(result, var_ast, BP_VAR_IS, 0, 0);
                        opline->opcode = ZEND_ISSET_ISEMPTY_STATIC_PROP;
                        break;
                EMPTY_SWITCH_DEFAULT_CASE()
@@ -7593,7 +7708,7 @@ void zend_compile_array(znode *result, zend_ast *ast) /* {{{ */
 
                if (by_ref) {
                        zend_ensure_writable_variable(value_ast);
-                       zend_compile_var(&value_node, value_ast, BP_VAR_W);
+                       zend_compile_var(&value_node, value_ast, BP_VAR_W, 1);
                } else {
                        zend_compile_expr(&value_node, value_ast);
                }
@@ -7709,7 +7824,7 @@ void zend_compile_class_const(znode *result, zend_ast *ast) /* {{{ */
 
        zend_set_class_name_op1(opline, &class_node);
 
-       opline->extended_value = zend_alloc_polymorphic_cache_slot();
+       opline->extended_value = zend_alloc_cache_slots(2);
 }
 /* }}} */
 
@@ -8146,8 +8261,8 @@ void zend_compile_stmt(zend_ast *ast) /* {{{ */
                case ZEND_AST_METHOD:
                        zend_compile_func_decl(NULL, ast, 0);
                        break;
-               case ZEND_AST_PROP_DECL:
-                       zend_compile_prop_decl(ast);
+               case ZEND_AST_PROP_GROUP:
+                       zend_compile_prop_group(ast);
                        break;
                case ZEND_AST_CLASS_CONST_DECL:
                        zend_compile_class_const_decl(ast);
@@ -8207,7 +8322,7 @@ void zend_compile_expr(znode *result, zend_ast *ast) /* {{{ */
                case ZEND_AST_CALL:
                case ZEND_AST_METHOD_CALL:
                case ZEND_AST_STATIC_CALL:
-                       zend_compile_var(result, ast, BP_VAR_R);
+                       zend_compile_var(result, ast, BP_VAR_R, 0);
                        return;
                case ZEND_AST_ASSIGN:
                        zend_compile_assign(result, ast);
@@ -8314,35 +8429,31 @@ void zend_compile_expr(znode *result, zend_ast *ast) /* {{{ */
 }
 /* }}} */
 
-void zend_compile_var(znode *result, zend_ast *ast, uint32_t type) /* {{{ */
+zend_op *zend_compile_var(znode *result, zend_ast *ast, uint32_t type, int by_ref) /* {{{ */
 {
        CG(zend_lineno) = zend_ast_get_lineno(ast);
 
        switch (ast->kind) {
                case ZEND_AST_VAR:
-                       zend_compile_simple_var(result, ast, type, 0);
-                       return;
+                       return zend_compile_simple_var(result, ast, type, 0);
                case ZEND_AST_DIM:
-                       zend_compile_dim(result, ast, type);
-                       return;
+                       return zend_compile_dim(result, ast, type);
                case ZEND_AST_PROP:
-                       zend_compile_prop(result, ast, type);
-                       return;
+                       return zend_compile_prop(result, ast, type, by_ref);
                case ZEND_AST_STATIC_PROP:
-                       zend_compile_static_prop(result, ast, type, 0);
-                       return;
+                       return zend_compile_static_prop(result, ast, type, by_ref, 0);
                case ZEND_AST_CALL:
                        zend_compile_call(result, ast, type);
-                       return;
+                       return NULL;
                case ZEND_AST_METHOD_CALL:
                        zend_compile_method_call(result, ast, type);
-                       return;
+                       return NULL;
                case ZEND_AST_STATIC_CALL:
                        zend_compile_static_call(result, ast, type);
-                       return;
+                       return NULL;
                case ZEND_AST_ZNODE:
                        *result = *zend_ast_get_znode(ast);
-                       return;
+                       return NULL;
                default:
                        if (type == BP_VAR_W || type == BP_VAR_RW || type == BP_VAR_UNSET) {
                                zend_error_noreturn(E_COMPILE_ERROR,
@@ -8350,29 +8461,30 @@ void zend_compile_var(znode *result, zend_ast *ast, uint32_t type) /* {{{ */
                        }
 
                        zend_compile_expr(result, ast);
-                       return;
+                       return NULL;
        }
 }
 /* }}} */
 
-void zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t type) /* {{{ */
+zend_op *zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t type, zend_bool by_ref) /* {{{ */
 {
        switch (ast->kind) {
                case ZEND_AST_VAR:
-                       zend_compile_simple_var(result, ast, type, 1);
-                       return;
+                       return zend_compile_simple_var(result, ast, type, 1);
                case ZEND_AST_DIM:
-                       zend_delayed_compile_dim(result, ast, type);
-                       return;
+                       return zend_delayed_compile_dim(result, ast, type);
                case ZEND_AST_PROP:
-                       zend_delayed_compile_prop(result, ast, type);
-                       return;
+               {
+                       zend_op *opline = zend_delayed_compile_prop(result, ast, type);
+                       if (by_ref) {
+                               opline->extended_value |= ZEND_FETCH_REF;
+                       }
+                       return opline;
+               }
                case ZEND_AST_STATIC_PROP:
-                       zend_compile_static_prop(result, ast, type, 1);
-                       return;
+                       return zend_compile_static_prop(result, ast, type, by_ref, 1);
                default:
-                       zend_compile_var(result, ast, type);
-                       return;
+                       return zend_compile_var(result, ast, type, 0);
        }
 }
 /* }}} */

diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index 892a7af423eee3bb3e4c72d5a08468fb512f9958..07c8a1768f4d996a94061c45fc94f37d032ce554 100644 (file)
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -128,7 +128,7 @@ typedef union _zend_parser_stack_elem {
 void zend_compile_top_stmt(zend_ast *ast);
 void zend_compile_stmt(zend_ast *ast);
 void zend_compile_expr(znode *node, zend_ast *ast);
-void zend_compile_var(znode *node, zend_ast *ast, uint32_t type);
+zend_op *zend_compile_var(znode *node, zend_ast *ast, uint32_t type, int by_ref);
 void zend_eval_const_expr(zend_ast **ast_ptr);
 void zend_const_expr_to_zval(zval *result, zend_ast *ast);
 
@@ -221,7 +221,7 @@ typedef struct _zend_oparray_context {
 #define ZEND_ACC_IMMUTABLE               (1 <<  7) /*  X  |  X  |     |     */
 /*                                                        |     |     |     */
 /* Function has typed arguments / class has typed props   |     |     |     */
-#define ZEND_ACC_HAS_TYPE_HINTS          (1 <<  8) /*  ?  |  X  |     |     */
+#define ZEND_ACC_HAS_TYPE_HINTS          (1 <<  8) /*  X  |  X  |     |     */
 /*                                                        |     |     |     */
 /* Top-level class or function declaration                |     |     |     */
 #define ZEND_ACC_TOP_LEVEL               (1 <<  9) /*  X  |  X  |     |     */
@@ -334,6 +334,7 @@ typedef struct _zend_property_info {
        zend_string *name;
        zend_string *doc_comment;
        zend_class_entry *ce;
+       zend_type type;
 } zend_property_info;
 
 #define OBJ_PROP(obj, offset) \
@@ -796,6 +797,12 @@ ZEND_API zend_string *zend_mangle_property_name(const char *src1, size_t src1_le
         zend_unmangle_property_name_ex(mangled_property, class_name, prop_name, NULL)
 ZEND_API int zend_unmangle_property_name_ex(const zend_string *name, const char **class_name, const char **prop_name, size_t *prop_len);
 
+static zend_always_inline const char *zend_get_unmangled_property_name(const zend_string *mangled_prop) {
+       const char *class_name, *prop_name;
+       zend_unmangle_property_name(mangled_prop, &class_name, &prop_name);
+       return prop_name;
+}
+
 #define ZEND_FUNCTION_DTOR zend_function_dtor
 #define ZEND_CLASS_DTOR destroy_zend_class
 
@@ -891,6 +898,12 @@ void zend_assert_valid_class_name(const zend_string *const_name);
 
 #define ZEND_FETCH_TYPE_MASK   0xe
 
+/* Only one of these can ever be in use */
+#define ZEND_FETCH_REF                 1
+#define ZEND_FETCH_DIM_WRITE   2
+#define ZEND_FETCH_OBJ_WRITE   3
+#define ZEND_FETCH_OBJ_FLAGS   3
+
 #define ZEND_ISEMPTY                   (1<<0)
 
 #define ZEND_LAST_CATCH                        (1<<0)

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index 4f334c6b8604f768773c1e84352cf6a66c8a6566..363812e01ff9581f2f36619ffc808105c81994c2 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -626,7 +626,7 @@ static zend_never_inline ZEND_COLD int zend_wrong_assign_to_variable_reference(z
                return 0;
        }
 
-       value_ptr = zend_assign_to_variable(variable_ptr, value_ptr, value_type);
+       value_ptr = zend_assign_to_variable(variable_ptr, value_ptr, value_type, EX_USES_STRICT_TYPES());
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                ZVAL_COPY(EX_VAR(opline->result.var), value_ptr);
@@ -634,16 +634,63 @@ static zend_never_inline ZEND_COLD int zend_wrong_assign_to_variable_reference(z
        return 1;
 }
 
+static void zend_format_type(zend_type type, const char **part1, const char **part2) {
+       *part1 = ZEND_TYPE_ALLOW_NULL(type) ? "?" : "";
+       if (ZEND_TYPE_IS_CLASS(type)) {
+               if (ZEND_TYPE_IS_CE(type)) {
+                       *part2 = ZSTR_VAL(ZEND_TYPE_CE(type)->name);
+               } else {
+                       *part2 = ZSTR_VAL(ZEND_TYPE_NAME(type));
+               }
+       } else {
+               *part2 = zend_get_type_by_const(ZEND_TYPE_CODE(type));
+       }
+}
+
+static zend_never_inline ZEND_COLD void zend_throw_auto_init_in_prop_error(zend_property_info *prop, const char *type) {
+       const char *prop_type1, *prop_type2;
+       zend_format_type(prop->type, &prop_type1, &prop_type2);
+       zend_type_error(
+               "Cannot auto-initialize an %s inside property %s::$%s of type %s%s",
+               type,
+               ZSTR_VAL(prop->ce->name), zend_get_unmangled_property_name(prop->name),
+               prop_type1, prop_type2
+       );
+}
+
+static zend_never_inline ZEND_COLD void zend_throw_auto_init_in_ref_error(zend_property_info *prop, const char *type) {
+       const char *prop_type1, *prop_type2;
+       zend_format_type(prop->type, &prop_type1, &prop_type2);
+       zend_type_error(
+               "Cannot auto-initialize an %s inside a reference held by property %s::$%s of type %s%s",
+               type,
+               ZSTR_VAL(prop->ce->name), zend_get_unmangled_property_name(prop->name),
+               prop_type1, prop_type2
+       );
+}
+
+static zend_never_inline ZEND_COLD void zend_throw_access_uninit_prop_by_ref_error(
+               zend_property_info *prop) {
+       zend_throw_error(NULL,
+               "Cannot access uninitialized non-nullable property %s::$%s by reference",
+               ZSTR_VAL(prop->ce->name),
+               zend_get_unmangled_property_name(prop->name));
+}
+
+static zend_always_inline zend_property_info *i_zend_check_ref_stdClass_assignable(zend_reference *ref);
+
 /* this should modify object only if it's empty */
-static zend_never_inline ZEND_COLD int ZEND_FASTCALL make_real_object(zval *object, zval *property OPLINE_DC EXECUTE_DATA_DC)
+static zend_never_inline ZEND_COLD zval* ZEND_FASTCALL make_real_object(zval *object, zval *property OPLINE_DC EXECUTE_DATA_DC)
 {
        zend_object *obj;
+       zval *ref = NULL;
+       if (Z_ISREF_P(object)) {
+               ref = object;
+               object = Z_REFVAL_P(object);
+       }
 
-       if (EXPECTED(Z_TYPE_P(object) <= IS_FALSE)) {
-               /* nothing to destroy */
-       } else if (EXPECTED((Z_TYPE_P(object) == IS_STRING && Z_STRLEN_P(object) == 0))) {
-               zval_ptr_dtor_nogc(object);
-       } else {
+       if (UNEXPECTED(Z_TYPE_P(object) > IS_FALSE &&
+                       (Z_TYPE_P(object) != IS_STRING || Z_STRLEN_P(object) != 0))) {
                if (opline->op1_type != IS_VAR || EXPECTED(!Z_ISERROR_P(object))) {
                        zend_string *tmp_property_name;
                        zend_string *property_name = zval_get_tmp_string(property, &tmp_property_name);
@@ -661,8 +708,21 @@ static zend_never_inline ZEND_COLD int ZEND_FASTCALL make_real_object(zval *obje
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
-               return 0;
+               return NULL;
        }
+
+       if (ref) {
+               zend_property_info *error_prop = i_zend_check_ref_stdClass_assignable(Z_REF_P(ref));
+               if (error_prop) {
+                       zend_throw_auto_init_in_ref_error(error_prop, "stdClass");
+                       if (RETURN_VALUE_USED(opline)) {
+                               ZVAL_UNDEF(EX_VAR(opline->result.var));
+                       }
+                       return NULL;
+               }
+       }
+
+       zval_ptr_dtor_nogc(object);
        object_init(object);
        Z_ADDREF_P(object);
        obj = Z_OBJ_P(object);
@@ -673,29 +733,42 @@ static zend_never_inline ZEND_COLD int ZEND_FASTCALL make_real_object(zval *obje
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
-               return 0;
+               return NULL;
        }
        Z_DELREF_P(object);
-       return 1;
+       return object;
 }
 
-static zend_never_inline ZEND_COLD int ZEND_FASTCALL make_real_object_rw(zval *object, zval *property OPLINE_DC)
+static zend_never_inline ZEND_COLD zval* ZEND_FASTCALL make_real_object_rw(zval *object, zval *property OPLINE_DC)
 {
-       if (EXPECTED(Z_TYPE_P(object) <= IS_FALSE)) {
-               /* nothing to destroy */
-       } else if (EXPECTED((Z_TYPE_P(object) == IS_STRING && Z_STRLEN_P(object) == 0))) {
-               zval_ptr_dtor_nogc(object);
-       } else {
+       zval *ref = NULL;
+       if (Z_ISREF_P(object)) {
+               ref = object;
+               object = Z_REFVAL_P(object);
+       }
+
+       if (UNEXPECTED(Z_TYPE_P(object) > IS_FALSE &&
+                       (Z_TYPE_P(object) != IS_STRING || Z_STRLEN_P(object) != 0))) {
                if (opline->op1_type != IS_VAR || EXPECTED(!Z_ISERROR_P(object))) {
                        zend_string *tmp_property_name;
                        zend_string *property_name = zval_get_tmp_string(property, &tmp_property_name);
                        zend_error(E_WARNING, "Attempt to modify property '%s' of non-object", ZSTR_VAL(property_name));
                        zend_tmp_string_release(tmp_property_name);
                }
-               return 0;
+               return NULL;
+       }
+
+       if (ref) {
+               zend_property_info *error_prop = i_zend_check_ref_stdClass_assignable(Z_REF_P(ref));
+               if (error_prop) {
+                       zend_throw_auto_init_in_ref_error(error_prop, "stdClass");
+                       return NULL;
+               }
        }
+
+       zval_ptr_dtor_nogc(object);
        object_init(object);
-       return 1;
+       return object;
 }
 
 static ZEND_COLD void zend_verify_type_error_common(
@@ -875,17 +948,125 @@ static zend_bool zend_verify_scalar_type_hint(zend_uchar type_hint, zval *arg, z
        return zend_verify_weak_scalar_type_hint(type_hint, arg);
 }
 
+ZEND_COLD zend_never_inline void zend_verify_property_type_error(zend_property_info *info, zval *property)
+{
+       const char *prop_type1, *prop_type2;
+
+       /* we _may_ land here in case reading already errored and runtime cache thus has not been updated (i.e. it contains a valid but unrelated info) */
+       if (EG(exception)) {
+               return;
+       }
+
+       // TODO Switch to a more standard error message?
+       zend_format_type(info->type, &prop_type1, &prop_type2);
+       (void) prop_type1;
+       if (ZEND_TYPE_IS_CLASS(info->type)) {
+               zend_type_error("Typed property %s::$%s must be an instance of %s%s, %s used",
+                       ZSTR_VAL(info->ce->name),
+                       zend_get_unmangled_property_name(info->name),
+                       prop_type2,
+                       ZEND_TYPE_ALLOW_NULL(info->type) ? " or null" : "",
+                       Z_TYPE_P(property) == IS_OBJECT ? ZSTR_VAL(Z_OBJCE_P(property)->name) : zend_get_type_by_const(Z_TYPE_P(property)));
+       } else {
+               zend_type_error("Typed property %s::$%s must be %s%s, %s used",
+                       ZSTR_VAL(info->ce->name),
+                       zend_get_unmangled_property_name(info->name),
+                       prop_type2,
+                       ZEND_TYPE_ALLOW_NULL(info->type) ? " or null" : "",
+                       Z_TYPE_P(property) == IS_OBJECT ? ZSTR_VAL(Z_OBJCE_P(property)->name) : zend_get_type_by_const(Z_TYPE_P(property)));
+       }
+}
+
+static zend_bool zend_resolve_class_type(zend_type *type, zend_class_entry *self_ce) {
+       zend_class_entry *ce;
+       zend_string *name = ZEND_TYPE_NAME(*type);
+       if (zend_string_equals_literal_ci(name, "self")) {
+               /* We need to explicitly check for this here, to avoid updating the type in the trait and
+                * later using the wrong "self" when the trait is used in a class. */
+               if (UNEXPECTED((self_ce->ce_flags & ZEND_ACC_TRAIT) != 0)) {
+                       zend_throw_error(NULL, "Cannot write a%s value to a 'self' typed static property of a trait", ZEND_TYPE_ALLOW_NULL(*type) ? " non-null" : "");
+                       return 0;
+               }
+               ce = self_ce;
+       } else if (zend_string_equals_literal_ci(name, "parent")) {
+               if (UNEXPECTED(!self_ce->parent)) {
+                       zend_throw_error(NULL, "Cannot access parent:: when current class scope has no parent");
+                       return 0;
+               }
+               ce = self_ce->parent;
+       } else {
+               ce = zend_lookup_class(name);
+               if (UNEXPECTED(!ce)) {
+                       return 0;
+               }
+       }
+
+       zend_string_release(name);
+       *type = ZEND_TYPE_ENCODE_CE(ce, ZEND_TYPE_ALLOW_NULL(*type));
+       return 1;
+}
+
+
+static zend_always_inline zend_bool i_zend_check_property_type(zend_property_info *info, zval *property, zend_bool strict)
+{
+       ZEND_ASSERT(!Z_ISREF_P(property));
+       if (ZEND_TYPE_IS_CLASS(info->type)) {
+               if (UNEXPECTED(Z_TYPE_P(property) != IS_OBJECT)) {
+                       return Z_TYPE_P(property) == IS_NULL && ZEND_TYPE_ALLOW_NULL(info->type);
+               }
+
+               if (UNEXPECTED(!ZEND_TYPE_IS_CE(info->type)) && UNEXPECTED(!zend_resolve_class_type(&info->type, info->ce))) {
+                       return 0;
+               }
+
+               return instanceof_function(Z_OBJCE_P(property), ZEND_TYPE_CE(info->type));
+       }
+
+       ZEND_ASSERT(ZEND_TYPE_CODE(info->type) != IS_CALLABLE);
+       if (EXPECTED(ZEND_TYPE_CODE(info->type) == Z_TYPE_P(property))) {
+               return 1;
+       } else if (EXPECTED(Z_TYPE_P(property) == IS_NULL)) {
+               return ZEND_TYPE_ALLOW_NULL(info->type);
+       } else if (ZEND_TYPE_CODE(info->type) == _IS_BOOL && EXPECTED(Z_TYPE_P(property) == IS_FALSE || Z_TYPE_P(property) == IS_TRUE)) {
+               return 1;
+       } else if (ZEND_TYPE_CODE(info->type) == IS_ITERABLE) {
+               return zend_is_iterable(property);
+       } else {
+               return zend_verify_scalar_type_hint(ZEND_TYPE_CODE(info->type), property, strict);
+       }
+}
+
+static zend_bool zend_always_inline i_zend_verify_property_type(zend_property_info *info, zval *property, zend_bool strict)
+{
+       if (i_zend_check_property_type(info, property, strict)) {
+               return 1;
+       }
+
+       zend_verify_property_type_error(info, property);
+       return 0;
+}
+
+zend_bool zend_never_inline zend_verify_property_type(zend_property_info *info, zval *property, zend_bool strict) {
+       return i_zend_verify_property_type(info, property, strict);
+}
+
 static zend_always_inline zend_bool zend_check_type(
                zend_type type,
                zval *arg, zend_class_entry **ce, void **cache_slot,
                zval *default_value, zend_class_entry *scope,
                zend_bool is_return_type)
 {
+       zend_reference *ref = NULL;
+
        if (!ZEND_TYPE_IS_SET(type)) {
                return 1;
        }
 
-       ZVAL_DEREF(arg);
+       if (UNEXPECTED(Z_ISREF_P(arg))) {
+               ref = Z_REF_P(arg);
+               arg = Z_REFVAL_P(arg);
+       }
+
        if (ZEND_TYPE_IS_CLASS(type)) {
                if (EXPECTED(*cache_slot)) {
                        *ce = (zend_class_entry *) *cache_slot;
@@ -916,6 +1097,8 @@ static zend_always_inline zend_bool zend_check_type(
        } else if (ZEND_TYPE_CODE(type) == _IS_BOOL &&
                           EXPECTED(Z_TYPE_P(arg) == IS_FALSE || Z_TYPE_P(arg) == IS_TRUE)) {
                return 1;
+       } else if (ref && ZEND_REF_HAS_TYPE_SOURCES(ref)) {
+               return 0; /* we cannot have conversions for typed refs */
        } else {
                return zend_verify_scalar_type_hint(ZEND_TYPE_CODE(type), arg,
                        is_return_type ? ZEND_RET_USES_STRICT_TYPES() : ZEND_ARG_USES_STRICT_TYPES());
@@ -1393,6 +1576,159 @@ static zend_never_inline void zend_assign_to_string_offset(zval *str, zval *dim,
        }
 }
 
+static zend_property_info *zend_get_prop_not_accepting_double(zend_reference *ref)
+{
+       zend_property_info *prop;
+       ZEND_REF_FOREACH_TYPE_SOURCES(ref, prop) {
+               if (ZEND_TYPE_CODE(prop->type) != IS_DOUBLE) {
+                       return prop;
+               }
+       } ZEND_REF_FOREACH_TYPE_SOURCES_END();
+       return NULL;
+}
+
+static ZEND_COLD void zend_throw_incdec_ref_error(zend_reference *ref, zend_bool inc)
+{
+       zend_property_info *error_prop = zend_get_prop_not_accepting_double(ref);
+       /* Currently there should be no way for a typed reference to accept both int and double.
+        * Generalize this and the related property code once this becomes possible. */
+       ZEND_ASSERT(error_prop);
+       zend_type_error(
+               "Cannot %s a reference held by property %s::$%s of type %sint past its %simal value",
+               inc ? "increment" : "decrement",
+               ZSTR_VAL(error_prop->ce->name),
+               zend_get_unmangled_property_name(error_prop->name),
+               ZEND_TYPE_ALLOW_NULL(error_prop->type) ? "?" : "",
+               inc ? "max" : "min");
+}
+
+static ZEND_COLD void zend_throw_incdec_prop_error(zend_property_info *prop, zend_bool inc) {
+       const char *prop_type1, *prop_type2;
+       zend_format_type(prop->type, &prop_type1, &prop_type2);
+       zend_type_error("Cannot %s property %s::$%s of type %s%s past its %simal value",
+               inc ? "increment" : "decrement",
+               ZSTR_VAL(prop->ce->name),
+               zend_get_unmangled_property_name(prop->name),
+               prop_type1, prop_type2,
+               inc ? "max" : "min");
+}
+
+static void zend_pre_incdec_property_zval(zval *prop, zend_property_info *prop_info, int inc OPLINE_DC EXECUTE_DATA_DC)
+{
+       if (EXPECTED(Z_TYPE_P(prop) == IS_LONG)) {
+               if (inc) {
+                       fast_long_increment_function(prop);
+               } else {
+                       fast_long_decrement_function(prop);
+               }
+               if (UNEXPECTED(Z_TYPE_P(prop) != IS_LONG) && UNEXPECTED(prop_info)) {
+                       zend_throw_incdec_prop_error(prop_info, inc);
+                       if (inc) {
+                               ZVAL_LONG(prop, ZEND_LONG_MAX);
+                       } else {
+                               ZVAL_LONG(prop, ZEND_LONG_MIN);
+                       }
+               }
+       } else {
+               zend_reference *ref = NULL;
+               if (Z_ISREF_P(prop)) {
+                       if (ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(prop))) {
+                               ref = Z_REF_P(prop);
+                       }
+                       prop = Z_REFVAL_P(prop);
+               }
+
+               if (UNEXPECTED(ref || prop_info)) {
+                       zval z_copy;
+                       ZVAL_COPY(&z_copy, prop);
+                       if (inc) {
+                               increment_function(&z_copy);
+                       } else {
+                               decrement_function(&z_copy);
+                       }
+                       if (UNEXPECTED(Z_TYPE(z_copy) == IS_DOUBLE) && Z_TYPE_P(prop) == IS_LONG) {
+                               if (prop_info) {
+                                       zend_throw_incdec_prop_error(prop_info, inc);
+                               } else {
+                                       zend_throw_incdec_ref_error(ref, inc);
+                               }
+                       } else if (EXPECTED(ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(prop);
+                               ZVAL_COPY_VALUE(prop, &z_copy);
+                       } else {
+                               zval_ptr_dtor(&z_copy);
+                       }
+               } else {
+                       if (inc) {
+                               increment_function(prop);
+                       } else {
+                               decrement_function(prop);
+                       }
+               }
+       }
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+       }
+}
+
+static void zend_post_incdec_property_zval(zval *prop, zend_property_info *prop_info, int inc OPLINE_DC EXECUTE_DATA_DC)
+{
+       if (EXPECTED(Z_TYPE_P(prop) == IS_LONG)) {
+               ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(prop));
+               if (inc) {
+                       fast_long_increment_function(prop);
+               } else {
+                       fast_long_decrement_function(prop);
+               }
+               if (UNEXPECTED(Z_TYPE_P(prop) != IS_LONG) && UNEXPECTED(prop_info)) {
+                       zend_throw_incdec_prop_error(prop_info, inc);
+                       if (inc) {
+                               ZVAL_LONG(prop, ZEND_LONG_MAX);
+                       } else {
+                               ZVAL_LONG(prop, ZEND_LONG_MIN);
+                       }
+               }
+       } else {
+               zend_reference *ref = NULL;
+               if (Z_ISREF_P(prop)) {
+                       if (ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(prop))) {
+                               ref = Z_REF_P(prop);
+                       }
+                       prop = Z_REFVAL_P(prop);
+               }
+
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+
+               if (UNEXPECTED(ref || prop_info)) {
+                       zval z_copy;
+                       ZVAL_COPY(&z_copy, prop);
+                       if (inc) {
+                               increment_function(&z_copy);
+                       } else {
+                               decrement_function(&z_copy);
+                       }
+                       if (UNEXPECTED(Z_TYPE(z_copy) == IS_DOUBLE) && Z_TYPE_P(prop) == IS_LONG) {
+                               if (prop_info) {
+                                       zend_throw_incdec_prop_error(prop_info, inc);
+                               } else {
+                                       zend_throw_incdec_ref_error(ref, inc);
+                               }
+                       } else if (EXPECTED(ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(prop);
+                               ZVAL_COPY_VALUE(prop, &z_copy);
+                       } else {
+                               zval_ptr_dtor(&z_copy);
+                       }
+               } else {
+                       if (inc) {
+                               increment_function(prop);
+                       } else {
+                               decrement_function(prop);
+                       }
+               }
+       }
+}
+
 static zend_never_inline void zend_post_incdec_overloaded_property(zval *object, zval *property, void **cache_slot, int inc OPLINE_DC EXECUTE_DATA_DC)
 {
        zval rv, obj;
@@ -1743,7 +2079,7 @@ static zend_never_inline zval* ZEND_FASTCALL zend_fetch_dimension_address_inner_
 
 static zend_always_inline void zend_fetch_dimension_address(zval *result, zval *container, zval *dim, int dim_type, int type EXECUTE_DATA_DC)
 {
-    zval *retval;
+       zval *retval, *orig_container = container;
 
        if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
 try_array:
@@ -1821,8 +2157,14 @@ fetch_from_array:
                }
                if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
                        if (type != BP_VAR_UNSET) {
-                               array_init(container);
-                               goto fetch_from_array;
+                               zend_property_info *error_prop;
+                               if (UNEXPECTED(orig_container != container) && Z_ISREF_P(orig_container) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_container))) != NULL) {
+                                       zend_throw_auto_init_in_ref_error(error_prop, "array");
+                                       ZVAL_ERROR(result);
+                               } else {
+                                       array_init(container);
+                                       goto fetch_from_array;
+                               }
                        } else {
                                /* for read-mode only */
                                ZVAL_NULL(result);
@@ -2150,21 +2492,151 @@ static zend_never_inline uint32_t ZEND_FASTCALL zend_array_key_exists_slow(zval
        }
 }
 
-static zend_always_inline void zend_fetch_property_address(zval *result, zval *container, uint32_t container_op_type, zval *prop_ptr, uint32_t prop_op_type, void **cache_slot, int type OPLINE_DC)
+static zend_always_inline zend_bool promotes_to_array(zval *val) {
+       return Z_TYPE_P(val) <= IS_FALSE
+               || (Z_ISREF_P(val) && Z_TYPE_P(Z_REFVAL_P(val)) <= IS_FALSE);
+}
+
+static zend_always_inline zend_bool promotes_to_object(zval *val) {
+       ZVAL_DEREF(val);
+       return Z_TYPE_P(val) <= IS_FALSE
+               || (Z_TYPE_P(val) == IS_STRING && Z_STRLEN_P(val) == 0);
+}
+
+static zend_always_inline zend_bool check_type_array_assignable(zend_type type) {
+       if (!type) {
+               return 1;
+       }
+       return ZEND_TYPE_IS_CODE(type)
+               && (ZEND_TYPE_CODE(type) == IS_ARRAY || ZEND_TYPE_CODE(type) == IS_ITERABLE);
+}
+
+static zend_always_inline zend_bool check_type_stdClass_assignable(zend_type type) {
+       if (!type) {
+               return 1;
+       }
+       if (ZEND_TYPE_IS_CLASS(type)) {
+               if (ZEND_TYPE_IS_CE(type)) {
+                       return ZEND_TYPE_CE(type) == zend_standard_class_def;
+               } else {
+                       return zend_string_equals_literal_ci(ZEND_TYPE_NAME(type), "stdclass");
+               }
+       } else {
+               return ZEND_TYPE_CODE(type) == IS_OBJECT;
+       }
+}
+
+/* Checks whether an array can be assigned to the reference. Returns conflicting property if
+ * assignment is not possible, NULL otherwise. */
+static zend_always_inline zend_property_info *i_zend_check_ref_array_assignable(zend_reference *ref) {
+       zend_property_info *prop;
+       if (!ZEND_REF_HAS_TYPE_SOURCES(ref)) {
+               return NULL;
+       }
+       ZEND_REF_FOREACH_TYPE_SOURCES(ref, prop) {
+               if (!check_type_array_assignable(prop->type)) {
+                       return prop;
+               }
+       } ZEND_REF_FOREACH_TYPE_SOURCES_END();
+       return NULL;
+}
+
+/* Checks whether an stdClass can be assigned to the reference. Returns conflicting property if
+ * assignment is not possible, NULL otherwise. */
+static zend_always_inline zend_property_info *i_zend_check_ref_stdClass_assignable(zend_reference *ref) {
+       zend_property_info *prop;
+       if (!ZEND_REF_HAS_TYPE_SOURCES(ref)) {
+               return NULL;
+       }
+       ZEND_REF_FOREACH_TYPE_SOURCES(ref, prop) {
+               if (!check_type_stdClass_assignable(prop->type)) {
+                       return prop;
+               }
+       } ZEND_REF_FOREACH_TYPE_SOURCES_END();
+       return NULL;
+}
+
+ZEND_API zend_property_info *zend_check_ref_array_assignable(zend_reference *ref) {
+       return i_zend_check_ref_array_assignable(ref);
+}
+
+static zend_always_inline zend_bool zend_need_to_handle_fetch_obj_flags(uint32_t flags, zval *ptr) {
+       return (flags == ZEND_FETCH_REF && Z_TYPE_P(ptr) != IS_REFERENCE)
+               || (flags == ZEND_FETCH_DIM_WRITE && promotes_to_array(ptr))
+               || (flags == ZEND_FETCH_OBJ_WRITE && promotes_to_object(ptr));
+}
+
+static zend_never_inline zend_bool zend_handle_fetch_obj_flags(
+               zval *result, zval *ptr, zend_property_info *prop_info, uint32_t flags)
+{
+       ZEND_ASSERT(prop_info && prop_info->type);
+       switch (flags) {
+               case ZEND_FETCH_DIM_WRITE:
+                       if (!check_type_array_assignable(prop_info->type)) {
+                               zend_throw_auto_init_in_prop_error(prop_info, "array");
+                               if (result) ZVAL_ERROR(result);
+                               return 0;
+                       }
+                       break;
+               case ZEND_FETCH_OBJ_WRITE:
+                       if (!check_type_stdClass_assignable(prop_info->type)) {
+                               zend_throw_auto_init_in_prop_error(prop_info, "stdClass");
+                               if (result) ZVAL_ERROR(result);
+                               return 0;
+                       }
+                       break;
+               case ZEND_FETCH_REF:
+                       if (Z_TYPE_P(ptr) == IS_UNDEF) {
+                               if (!ZEND_TYPE_ALLOW_NULL(prop_info->type)) {
+                                       zend_throw_access_uninit_prop_by_ref_error(prop_info);
+                                       if (result) ZVAL_ERROR(result);
+                                       return 0;
+                               }
+                               ZVAL_NULL(ptr);
+                       }
+
+                       ZVAL_NEW_REF(ptr, ptr);
+                       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(ptr), prop_info);
+                       break;
+               EMPTY_SWITCH_DEFAULT_CASE()
+       }
+       return 1;
+}
+
+static zend_always_inline zend_property_info *zend_object_fetch_property_type_info(
+               zend_object *obj, zval *slot)
+{
+       if (EXPECTED(!ZEND_CLASS_HAS_TYPE_HINTS(obj->ce))) {
+               return NULL;
+       }
+
+       /* Not a declared property */
+       if (UNEXPECTED(slot < obj->properties_table ||
+                       slot >= obj->properties_table + obj->ce->default_properties_count)) {
+               return NULL;
+       }
+
+       return zend_get_typed_property_info_for_slot(obj, slot);
+}
+
+static zend_always_inline void zend_fetch_property_address(zval *result, zval *container, uint32_t container_op_type, zval *prop_ptr, uint32_t prop_op_type, void **cache_slot, int type, uint32_t flags, zend_bool init_undef OPLINE_DC)
 {
        zval *ptr;
-    if (container_op_type != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
+
+       if (container_op_type != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) {
                do {
-                       if (Z_ISREF_P(container)) {
+                       if (Z_ISREF_P(container) && Z_TYPE_P(Z_REFVAL_P(container)) == IS_OBJECT) {
                                container = Z_REFVAL_P(container);
-                               if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
-                                       break;
-                               }
+                               break;
                        }
 
                        /* this should modify object only if it's empty */
-                       if (type == BP_VAR_UNSET ||
-                               UNEXPECTED(!make_real_object_rw(container, prop_ptr OPLINE_CC))) {
+                       if (type == BP_VAR_UNSET) {
+                               return;
+                       }
+
+                       container = make_real_object_rw(container, prop_ptr OPLINE_CC);
+                       if (UNEXPECTED(!container)) {
                                ZVAL_ERROR(result);
                                return;
                        }
@@ -2174,12 +2646,16 @@ static zend_always_inline void zend_fetch_property_address(zval *result, zval *c
            EXPECTED(Z_OBJCE_P(container) == CACHED_PTR_EX(cache_slot))) {
                uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(container);
-               zval *retval;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
-                       retval = OBJ_PROP(zobj, prop_offset);
-                       if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
-                               ZVAL_INDIRECT(result, retval);
+                       ptr = OBJ_PROP(zobj, prop_offset);
+                       if (EXPECTED(Z_TYPE_P(ptr) != IS_UNDEF)) {
+                               zend_property_info *prop_info;
+                               ZVAL_INDIRECT(result, ptr);
+                               if (flags && (prop_info = CACHED_PTR_EX(cache_slot + 2)) &&
+                                               UNEXPECTED(zend_need_to_handle_fetch_obj_flags(flags, ptr))) {
+                                       zend_handle_fetch_obj_flags(result, ptr, prop_info, flags);
+                               }
                                return;
                        }
                } else if (EXPECTED(zobj->properties != NULL)) {
@@ -2189,24 +2665,378 @@ static zend_always_inline void zend_fetch_property_address(zval *result, zval *c
                                }
                                zobj->properties = zend_array_dup(zobj->properties);
                        }
-                       retval = zend_hash_find_ex(zobj->properties, Z_STR_P(prop_ptr), 1);
-                       if (EXPECTED(retval)) {
-                               ZVAL_INDIRECT(result, retval);
+                       ptr = zend_hash_find_ex(zobj->properties, Z_STR_P(prop_ptr), 1);
+                       if (EXPECTED(ptr)) {
+                               ZVAL_INDIRECT(result, ptr);
                                return;
                        }
                }
        }
-
        ptr = Z_OBJ_HT_P(container)->get_property_ptr_ptr(container, prop_ptr, type, cache_slot);
        if (NULL == ptr) {
                ptr = Z_OBJ_HT_P(container)->read_property(container, prop_ptr, type, cache_slot, result);
-               if (ptr != result) {
-                       ZVAL_INDIRECT(result, ptr);
-               } else if (UNEXPECTED(Z_ISREF_P(ptr) && Z_REFCOUNT_P(ptr) == 1)) {
-                       ZVAL_UNREF(ptr);
+               if (ptr == result) {
+                       if (UNEXPECTED(Z_ISREF_P(ptr) && Z_REFCOUNT_P(ptr) == 1)) {
+                               ZVAL_UNREF(ptr);
+                       }
+                       return;
+               }
+       }
+
+       ZVAL_INDIRECT(result, ptr);
+       if (flags && UNEXPECTED(zend_need_to_handle_fetch_obj_flags(flags, ptr))) {
+               zend_property_info *prop_info =
+                       zend_object_fetch_property_type_info(Z_OBJ_P(container), ptr);
+               if (prop_info && !zend_handle_fetch_obj_flags(result, ptr, prop_info, flags)) {
+                       return;
+               }
+       }
+       if (init_undef && UNEXPECTED(Z_TYPE_P(ptr) == IS_UNDEF)) {
+               ZVAL_NULL(ptr);
+       }
+}
+
+static zend_never_inline int zend_fetch_static_property_address_ex(zval **retval, zend_property_info **prop_info, uint32_t cache_slot, int fetch_type OPLINE_DC EXECUTE_DATA_DC) {
+       zend_free_op free_op1;
+       zend_string *name, *tmp_name;
+       zend_class_entry *ce;
+       zend_property_info *property_info;
+
+       zend_uchar op1_type = opline->op1_type, op2_type = opline->op2_type;
+
+       if (EXPECTED(op2_type == IS_CONST)) {
+               zval *class_name = RT_CONSTANT(opline, opline->op2);
+
+               ZEND_ASSERT(op1_type != IS_CONST || CACHED_PTR(cache_slot) == NULL);
+
+               if (EXPECTED((ce = CACHED_PTR(cache_slot)) == NULL)) {
+                       ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
+                       if (UNEXPECTED(ce == NULL)) {
+                               FREE_UNFETCHED_OP(op1_type, opline->op1.var);
+                               return FAILURE;
+                       }
+                       if (UNEXPECTED(op1_type != IS_CONST)) {
+                               CACHE_PTR(cache_slot, ce);
+                       }
                }
        } else {
-               ZVAL_INDIRECT(result, ptr);
+               if (EXPECTED(op2_type == IS_UNUSED)) {
+                       ce = zend_fetch_class(NULL, opline->op2.num);
+                       if (UNEXPECTED(ce == NULL)) {
+                               FREE_UNFETCHED_OP(op1_type, opline->op1.var);
+                               return FAILURE;
+                       }
+               } else {
+                       ce = Z_CE_P(EX_VAR(opline->op2.var));
+               }
+               if (EXPECTED(op1_type == IS_CONST) && EXPECTED(CACHED_PTR(cache_slot) == ce)) {
+                       *retval = CACHED_PTR(cache_slot + sizeof(void *));
+                       *prop_info = CACHED_PTR(cache_slot + sizeof(void *) * 2);
+                       return SUCCESS;
+               }
+       }
+
+       if (EXPECTED(op1_type == IS_CONST)) {
+               name = Z_STR_P(RT_CONSTANT(opline, opline->op1));
+       } else {
+               zval *varname = get_zval_ptr_undef(opline->op1_type, opline->op1, &free_op1, BP_VAR_R);
+               if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
+                       name = Z_STR_P(varname);
+                       tmp_name = NULL;
+               } else {
+                       if (op1_type == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
+                               zval_undefined_cv(opline->op1.var EXECUTE_DATA_CC);
+                       }
+                       name = zval_get_tmp_string(varname, &tmp_name);
+               }
+       }
+
+       *retval = zend_std_get_static_property_with_info(ce, name, fetch_type, &property_info);
+
+       if (UNEXPECTED(op1_type != IS_CONST)) {
+               zend_tmp_string_release(tmp_name);
+
+               if (op1_type != IS_CV) {
+                       zval_ptr_dtor_nogc(free_op1);
+               }
+       }
+
+       if (UNEXPECTED(*retval == NULL)) {
+               return FAILURE;
+       }
+
+       *prop_info = property_info;
+
+       if (EXPECTED(op1_type == IS_CONST)) {
+               CACHE_POLYMORPHIC_PTR(cache_slot, ce, *retval);
+               CACHE_PTR(cache_slot + sizeof(void *) * 2, property_info);
+       }
+
+       return SUCCESS;
+}
+
+
+static zend_always_inline int zend_fetch_static_property_address(zval **retval, zend_property_info **prop_info, uint32_t cache_slot, int fetch_type, int flags OPLINE_DC EXECUTE_DATA_DC) {
+       int success;
+       zend_property_info *property_info;
+
+       if (opline->op1_type == IS_CONST && (opline->op2_type == IS_CONST || (opline->op2_type == IS_UNUSED && (opline->op2.num == ZEND_FETCH_CLASS_SELF || opline->op2.num == ZEND_FETCH_CLASS_PARENT))) && EXPECTED(CACHED_PTR(cache_slot) != NULL)) {
+               *retval = CACHED_PTR(cache_slot + sizeof(void *));
+               property_info = CACHED_PTR(cache_slot + sizeof(void *) * 2);
+
+               if ((fetch_type == BP_VAR_R || fetch_type == BP_VAR_RW)
+                               && UNEXPECTED(Z_TYPE_P(*retval) == IS_UNDEF) && UNEXPECTED(property_info->type != 0)) {
+                       zend_throw_error(NULL, "Typed static property %s::$%s must not be accessed before initialization",
+                               ZSTR_VAL(property_info->ce->name),
+                               zend_get_unmangled_property_name(property_info->name));
+                       return FAILURE;
+               }
+       } else {
+               success = zend_fetch_static_property_address_ex(retval, &property_info, cache_slot, fetch_type OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(success != SUCCESS)) {
+                       return FAILURE;
+               }
+       }
+
+       if (flags && property_info->type && zend_need_to_handle_fetch_obj_flags(flags, *retval)) {
+               zend_handle_fetch_obj_flags(NULL, *retval, property_info, flags);
+       }
+
+       if (prop_info) {
+               *prop_info = property_info;
+       }
+
+       return SUCCESS;
+}
+
+ZEND_API ZEND_COLD void zend_throw_ref_type_error_type(zend_property_info *prop1, zend_property_info *prop2, zval *zv) {
+       const char *prop1_type1, *prop1_type2, *prop2_type1, *prop2_type2;
+       zend_format_type(prop1->type, &prop1_type1, &prop1_type2);
+       zend_format_type(prop2->type, &prop2_type1, &prop2_type2);
+       zend_type_error("Reference with value of type %s held by property %s::$%s of type %s%s is not compatible with property %s::$%s of type %s%s",
+               Z_TYPE_P(zv) == IS_OBJECT ? ZSTR_VAL(Z_OBJCE_P(zv)->name) : zend_get_type_by_const(Z_TYPE_P(zv)),
+               ZSTR_VAL(prop1->ce->name),
+               zend_get_unmangled_property_name(prop1->name),
+               prop1_type1, prop1_type2,
+               ZSTR_VAL(prop2->ce->name),
+               zend_get_unmangled_property_name(prop2->name),
+               prop2_type1, prop2_type2
+       );
+}
+
+ZEND_API ZEND_COLD void zend_throw_ref_type_error_zval(zend_property_info *prop, zval *zv) {
+       const char *prop_type1, *prop_type2;
+       zend_format_type(prop->type, &prop_type1, &prop_type2);
+       zend_type_error("Cannot assign %s to reference held by property %s::$%s of type %s%s",
+               Z_TYPE_P(zv) == IS_OBJECT ? ZSTR_VAL(Z_OBJCE_P(zv)->name) : zend_get_type_by_const(Z_TYPE_P(zv)),
+               ZSTR_VAL(prop->ce->name),
+               zend_get_unmangled_property_name(prop->name),
+               prop_type1, prop_type2
+       );
+}
+
+ZEND_API ZEND_COLD void zend_throw_conflicting_coercion_error(zend_property_info *prop1, zend_property_info *prop2, zval *zv) {
+       const char *prop1_type1, *prop1_type2, *prop2_type1, *prop2_type2;
+       zend_format_type(prop1->type, &prop1_type1, &prop1_type2);
+       zend_format_type(prop2->type, &prop2_type1, &prop2_type2);
+       zend_type_error("Cannot assign %s to reference held by property %s::$%s of type %s%s and property %s::$%s of type %s%s, as this would result in an inconsistent type conversion",
+               Z_TYPE_P(zv) == IS_OBJECT ? ZSTR_VAL(Z_OBJCE_P(zv)->name) : zend_get_type_by_const(Z_TYPE_P(zv)),
+               ZSTR_VAL(prop1->ce->name),
+               zend_get_unmangled_property_name(prop1->name),
+               prop1_type1, prop1_type2,
+               ZSTR_VAL(prop2->ce->name),
+               zend_get_unmangled_property_name(prop2->name),
+               prop2_type1, prop2_type2
+       );
+}
+
+/* 1: valid, 0: invalid, -1: may be valid after type coercion */
+static zend_always_inline int i_zend_verify_type_assignable_zval(
+               zend_type *type_ptr, zend_class_entry *self_ce, zval *zv, zend_bool strict) {
+       zend_type type = *type_ptr;
+       zend_uchar type_code;
+       zend_uchar zv_type = Z_TYPE_P(zv);
+
+       if (ZEND_TYPE_ALLOW_NULL(type) && zv_type == IS_NULL) {
+               return 1;
+       }
+
+       if (ZEND_TYPE_IS_CLASS(type)) {
+               if (!ZEND_TYPE_IS_CE(type)) {
+                       if (!zend_resolve_class_type(type_ptr, self_ce)) {
+                               return 0;
+                       }
+                       type = *type_ptr;
+               }
+               return zv_type == IS_OBJECT && instanceof_function(Z_OBJCE_P(zv), ZEND_TYPE_CE(type));
+       }
+
+       type_code = ZEND_TYPE_CODE(type);
+       if (type_code == zv_type ||
+                       (type_code == _IS_BOOL && (zv_type == IS_FALSE || zv_type == IS_TRUE))) {
+               return 1;
+       }
+
+       if (type_code == IS_ITERABLE) {
+               return zend_is_iterable(zv);
+       }
+
+       /* SSTH Exception: IS_LONG may be accepted as IS_DOUBLE (converted) */
+       if (strict) {
+               if (type_code == IS_DOUBLE && zv_type == IS_LONG) {
+                       return -1;
+               }
+               return 0;
+       }
+
+       /* No weak conversions for arrays and objects */
+       if (type_code == IS_ARRAY || type_code == IS_OBJECT) {
+               return 0;
+       }
+
+       /* NULL may be accepted only by nullable hints (this is already checked) */
+       if (zv_type == IS_NULL) {
+               return 0;
+       }
+
+       /* Coercion may be necessary, check separately */
+       return -1;
+}
+
+static zend_always_inline zend_bool i_zend_verify_ref_assignable_zval(zend_reference *ref, zval *zv, zend_bool strict) {
+       zend_property_info *prop;
+
+       /* The value must satisfy each property type, and coerce to the same value for each property
+        * type. Right now, the latter rule means that *if* coercion is necessary, then all types
+        * must be the same (modulo nullability). To handle this, remember the first type we see and
+        * compare against it when coercion becomes necessary. */
+       zend_property_info *seen_prop = NULL;
+       zend_uchar seen_type;
+       zend_bool needs_coercion = 0;
+
+       ZEND_ASSERT(Z_TYPE_P(zv) != IS_REFERENCE);
+       ZEND_REF_FOREACH_TYPE_SOURCES(ref, prop) {
+               int result = i_zend_verify_type_assignable_zval(&prop->type, prop->ce, zv, strict);
+               if (result == 0) {
+                       zend_throw_ref_type_error_zval(prop, zv);
+                       return 0;
+               }
+
+               if (result < 0) {
+                       needs_coercion = 1;
+               }
+
+               if (!seen_prop) {
+                       seen_prop = prop;
+                       seen_type = ZEND_TYPE_IS_CLASS(prop->type) ? IS_OBJECT : ZEND_TYPE_CODE(prop->type);
+               } else if (needs_coercion && seen_type != ZEND_TYPE_CODE(prop->type)) {
+                       zend_throw_conflicting_coercion_error(seen_prop, prop, zv);
+                       return 0;
+               }
+       } ZEND_REF_FOREACH_TYPE_SOURCES_END();
+
+       if (UNEXPECTED(needs_coercion && !zend_verify_weak_scalar_type_hint(seen_type, zv))) {
+               zend_throw_ref_type_error_zval(seen_prop, zv);
+               return 0;
+       }
+
+       return 1;
+}
+
+ZEND_API zend_bool zend_verify_ref_assignable_zval(zend_reference *ref, zval *zv, zend_bool strict)
+{
+       return i_zend_verify_ref_assignable_zval(ref, zv, strict);
+}
+
+ZEND_API zend_bool zend_verify_prop_assignable_by_ref(zend_property_info *prop_info, zval *orig_val, zend_bool strict) {
+       zval *val = orig_val;
+       if (Z_ISREF_P(val) && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(val))) {
+               int result;
+
+               val = Z_REFVAL_P(val);
+               result = i_zend_verify_type_assignable_zval(&prop_info->type, prop_info->ce, val, strict);
+               if (result > 0) {
+                       return 1;
+               }
+
+               if (result < 0) {
+                       zend_property_info *ref_prop = ZEND_REF_FIRST_SOURCE(Z_REF_P(orig_val));
+                       if (ZEND_TYPE_CODE(prop_info->type) != ZEND_TYPE_CODE(ref_prop->type)) {
+                               /* Invalid due to conflicting coercion */
+                               zend_throw_ref_type_error_type(ref_prop, prop_info, val);
+                               return 0;
+                       }
+                       if (zend_verify_weak_scalar_type_hint(ZEND_TYPE_CODE(prop_info->type), val)) {
+                               return 1;
+                       }
+               }
+       } else {
+               ZVAL_DEREF(val);
+               if (i_zend_check_property_type(prop_info, val, strict)) {
+                       return 1;
+               }
+       }
+
+       zend_verify_property_type_error(prop_info, val);
+       return 0;
+}
+
+ZEND_API void zend_ref_add_type_source(zend_property_info_source_list *source_list, zend_property_info *prop)
+{
+       zend_property_info_list *list;
+       if (source_list->ptr == NULL) {
+               source_list->ptr = prop;
+               return;
+       }
+
+       list = ZEND_PROPERTY_INFO_SOURCE_TO_LIST(source_list->list);
+       if (!ZEND_PROPERTY_INFO_SOURCE_IS_LIST(source_list->list)) {
+               list = emalloc(sizeof(zend_property_info_list) + (4 - 1) * sizeof(zend_property_info *));
+               list->ptr[0] = source_list->ptr;
+               list->num_allocated = 4;
+               list->num = 1;
+       } else if (list->num_allocated == list->num) {
+               list->num_allocated = list->num * 2;
+               list = erealloc(list, sizeof(zend_property_info_list) + (list->num_allocated - 1) * sizeof(zend_property_info *));
+       }
+
+       list->ptr[list->num++] = prop;
+       source_list->list = ZEND_PROPERTY_INFO_SOURCE_FROM_LIST(list);
+}
+
+ZEND_API void zend_ref_del_type_source(zend_property_info_source_list *source_list, zend_property_info *prop)
+{
+       zend_property_info_list *list = ZEND_PROPERTY_INFO_SOURCE_TO_LIST(source_list->list);
+       zend_property_info **ptr, **end;
+
+       if (!ZEND_PROPERTY_INFO_SOURCE_IS_LIST(source_list->list)) {
+               ZEND_ASSERT(source_list->ptr == prop);
+               source_list->ptr = NULL;
+               return;
+       }
+
+       if (list->num == 1) {
+               ZEND_ASSERT(*list->ptr == prop);
+               efree(list);
+               source_list->ptr = NULL;
+               return;
+       }
+
+       /* Checking against end here to get a more graceful failure mode if we missed adding a type
+        * source at some point. */
+       ptr = list->ptr;
+       end = ptr + list->num;
+       while (ptr < end && *ptr != prop) {
+               ptr++;
+       }
+       ZEND_ASSERT(*ptr == prop);
+
+       /* Copy the last list element into the deleted slot. */
+       *ptr = list->ptr[--list->num];
+
+       if (list->num >= 4 && list->num * 4 == list->num_allocated) {
+               list->num_allocated = list->num * 2;
+               source_list->list = ZEND_PROPERTY_INFO_SOURCE_FROM_LIST(erealloc(list, sizeof(zend_property_info_list) + (list->num_allocated - 1) * sizeof(zend_property_info *)));
        }
 }
 

diff --git a/Zend/zend_execute.h b/Zend/zend_execute.h
index 72113e8fe72d439948c3f12e8b94d4ba39434ca0..1060b1f632ed4bf965a69c45c4f7a149bae68bdb 100644 (file)
--- a/Zend/zend_execute.h
+++ b/Zend/zend_execute.h
@@ -56,9 +56,34 @@ ZEND_API void ZEND_FASTCALL zend_check_internal_arg_type(zend_function *zf, uint
 ZEND_API int  ZEND_FASTCALL zend_check_arg_type(zend_function *zf, uint32_t arg_num, zval *arg, zval *default_value, void **cache_slot);
 ZEND_API ZEND_COLD void ZEND_FASTCALL zend_missing_arg_error(zend_execute_data *execute_data);
 
-static zend_always_inline zval* zend_assign_to_variable(zval *variable_ptr, zval *value, zend_uchar value_type)
+ZEND_API zend_type zend_check_typed_assign_typed_ref(const char *source, zend_type type, zend_reference *ref);
+
+ZEND_API zend_property_info *zend_check_ref_array_assignable(zend_reference *ref);
+ZEND_API zend_bool zend_verify_ref_assignable_zval(zend_reference *ref, zval *zv, zend_bool strict);
+ZEND_API zend_bool zend_verify_prop_assignable_by_ref(zend_property_info *prop_info, zval *orig_val, zend_bool strict);
+
+ZEND_API ZEND_COLD void zend_throw_ref_type_error_zval(zend_property_info *prop, zval *zv);
+ZEND_API ZEND_COLD void zend_throw_ref_type_error_type(zend_property_info *prop1, zend_property_info *prop2, zval *zv);
+
+#define ZEND_REF_TYPE_SOURCES(ref) \
+       (ref)->sources
+
+#define ZEND_REF_HAS_TYPE_SOURCES(ref) \
+       (ZEND_REF_TYPE_SOURCES(ref).ptr != NULL)
+
+#define ZEND_REF_FIRST_SOURCE(ref) \
+       (ZEND_PROPERTY_INFO_SOURCE_IS_LIST((ref)->sources.list) \
+               ? ZEND_PROPERTY_INFO_SOURCE_TO_LIST((ref)->sources.list)->ptr[0] \
+               : (ref)->sources.ptr)
+
+
+ZEND_API void zend_ref_add_type_source(zend_property_info_source_list *source_list, zend_property_info *prop);
+ZEND_API void zend_ref_del_type_source(zend_property_info_source_list *source_list, zend_property_info *prop);
+
+static zend_always_inline zval* zend_assign_to_variable(zval *variable_ptr, zval *value, zend_uchar value_type, zend_bool strict)
 {
        zend_refcounted *ref = NULL;
+       zval tmp;
 
        if (ZEND_CONST_COND(value_type & (IS_VAR|IS_CV), 1) && Z_ISREF_P(value)) {
                ref = Z_COUNTED_P(value);
@@ -70,6 +95,25 @@ static zend_always_inline zval* zend_assign_to_variable(zval *variable_ptr, zval
                        zend_refcounted *garbage;
 
                        if (Z_ISREF_P(variable_ptr)) {
+                               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(variable_ptr)))) {
+                                       zend_bool need_copy = ZEND_CONST_COND(value_type & (IS_CONST|IS_CV), 1) ||
+                                               ((value_type & IS_VAR) && UNEXPECTED(ref) && GC_REFCOUNT(ref) > 1);
+                                       if (need_copy) {
+                                               ZVAL_COPY(&tmp, value);
+                                               value = &tmp;
+                                       }
+                                       if (!zend_verify_ref_assignable_zval(Z_REF_P(variable_ptr), value, strict)) {
+                                               if (need_copy) {
+                                                       Z_TRY_DELREF_P(value);
+                                               }
+                                               zval_ptr_dtor(value);
+                                               return Z_REFVAL_P(variable_ptr);
+                                       }
+                                       if (need_copy) {
+                                               Z_TRY_DELREF_P(value);
+                                       }
+                               }
+
                                variable_ptr = Z_REFVAL_P(variable_ptr);
                                if (EXPECTED(!Z_REFCOUNTED_P(variable_ptr))) {
                                        break;
@@ -395,6 +439,39 @@ ZEND_API int ZEND_FASTCALL zend_do_fcall_overloaded(zend_execute_data *call, zva
                }                                                \
        } while (0)
 
+#define ZEND_CLASS_HAS_TYPE_HINTS(ce) ((ce->ce_flags & ZEND_ACC_HAS_TYPE_HINTS) == ZEND_ACC_HAS_TYPE_HINTS)
+
+zend_bool zend_verify_property_type(zend_property_info *info, zval *property, zend_bool strict);
+ZEND_COLD void zend_verify_property_type_error(zend_property_info *info, zval *property);
+
+#define ZEND_REF_ADD_TYPE_SOURCE(ref, source) \
+       zend_ref_add_type_source(&ZEND_REF_TYPE_SOURCES(ref), source)
+
+#define ZEND_REF_DEL_TYPE_SOURCE(ref, source) \
+       zend_ref_del_type_source(&ZEND_REF_TYPE_SOURCES(ref), source)
+
+#define ZEND_REF_FOREACH_TYPE_SOURCES(ref, prop) do { \
+               zend_property_info_source_list *_source_list = &ZEND_REF_TYPE_SOURCES(ref); \
+               zend_property_info **_prop, **_end; \
+               zend_property_info_list *_list; \
+               if (_source_list->ptr) { \
+                       if (ZEND_PROPERTY_INFO_SOURCE_IS_LIST(_source_list->list)) { \
+                               _list = ZEND_PROPERTY_INFO_SOURCE_TO_LIST(_source_list->list); \
+                               _prop = _list->ptr; \
+                               _end = _list->ptr + _list->num; \
+                       } else { \
+                               _prop = &_source_list->ptr; \
+                               _end = _prop + 1; \
+                       } \
+                       for (; _prop < _end; _prop++) { \
+                               prop = *_prop; \
+
+#define ZEND_REF_FOREACH_TYPE_SOURCES_END() \
+                       } \
+               } \
+       } while (0)
+
+
 END_EXTERN_C()
 
 #endif /* ZEND_EXECUTE_H */

diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c
index 387c1ca4d781037383eb7eb62262336a9bc47789..9dc26088f76bc85c3943452b0070df2be1a65d60 100644 (file)
--- a/Zend/zend_inheritance.c
+++ b/Zend/zend_inheritance.c
@@ -36,6 +36,10 @@ static zend_property_info *zend_duplicate_property_info_internal(zend_property_i
        zend_property_info* new_property_info = pemalloc(sizeof(zend_property_info), 1);
        memcpy(new_property_info, property_info, sizeof(zend_property_info));
        zend_string_addref(new_property_info->name);
+       if (ZEND_TYPE_IS_NAME(new_property_info->type)) {
+               zend_string_addref(ZEND_TYPE_NAME(new_property_info->type));
+       }
+
        return new_property_info;
 }
 /* }}} */
@@ -662,6 +666,55 @@ static zend_function *do_inherit_method(zend_string *key, zend_function *parent,
 }
 /* }}} */
 
+zend_string* zend_resolve_property_type(zend_string *type, zend_class_entry *scope) /* {{{ */
+{
+       if (zend_string_equals_literal_ci(type, "parent")) {
+               if (scope && scope->parent) {
+                       return scope->parent->name;
+               }
+       }
+
+       if (zend_string_equals_literal_ci(type, "self")) {
+               if (scope) {
+                       return scope->name;
+               }
+       }
+
+       return type;
+} /* }}} */
+
+zend_bool property_types_compatible(zend_property_info *parent_info, zend_property_info *child_info) {
+       zend_string *parent_name, *child_name;
+       zend_class_entry *parent_type_ce, *child_type_ce;
+       if (parent_info->type == child_info->type) {
+               return 1;
+       }
+
+       if (!ZEND_TYPE_IS_CLASS(parent_info->type) || !ZEND_TYPE_IS_CLASS(child_info->type) ||
+                       ZEND_TYPE_ALLOW_NULL(parent_info->type) != ZEND_TYPE_ALLOW_NULL(child_info->type)) {
+               return 0;
+       }
+
+       parent_name = ZEND_TYPE_IS_CE(parent_info->type)
+               ? ZEND_TYPE_CE(parent_info->type)->name
+               : zend_resolve_property_type(ZEND_TYPE_NAME(parent_info->type), parent_info->ce);
+       child_name = ZEND_TYPE_IS_CE(child_info->type)
+               ? ZEND_TYPE_CE(child_info->type)->name
+               : zend_resolve_property_type(ZEND_TYPE_NAME(child_info->type), child_info->ce);
+       if (zend_string_equals_ci(parent_name, child_name)) {
+               return 1;
+       }
+
+       /* Check for class aliases */
+       parent_type_ce = ZEND_TYPE_IS_CE(parent_info->type)
+               ? ZEND_TYPE_CE(parent_info->type)
+               : zend_lookup_class(parent_name);
+       child_type_ce = ZEND_TYPE_IS_CE(child_info->type)
+               ? ZEND_TYPE_CE(child_info->type)
+               : zend_lookup_class(child_name);
+       return parent_type_ce && child_type_ce && parent_type_ce == child_type_ce;
+}
+
 static void do_inherit_property(zend_property_info *parent_info, zend_string *key, zend_class_entry *ce) /* {{{ */
 {
        zval *child = zend_hash_find_ex(&ce->properties_info, key, 1);
@@ -691,6 +744,26 @@ static void do_inherit_property(zend_property_info *parent_info, zend_string *ke
                                ZVAL_UNDEF(&ce->default_properties_table[child_num]);
                                child_info->offset = parent_info->offset;
                        }
+
+                       if (UNEXPECTED(ZEND_TYPE_IS_SET(parent_info->type))) {
+                               if (!property_types_compatible(parent_info, child_info)) {
+                                       zend_error_noreturn(E_COMPILE_ERROR,
+                                       "Type of %s::$%s must be %s%s (as in class %s)",
+                                               ZSTR_VAL(ce->name),
+                                               ZSTR_VAL(key),
+                                               ZEND_TYPE_ALLOW_NULL(parent_info->type) ? "?" : "",
+                                               ZEND_TYPE_IS_CLASS(parent_info->type)
+                                                       ? ZSTR_VAL(ZEND_TYPE_IS_CE(parent_info->type) ? ZEND_TYPE_CE(parent_info->type)->name : zend_resolve_property_type(ZEND_TYPE_NAME(parent_info->type), parent_info->ce))
+                                                       : zend_get_type_by_const(ZEND_TYPE_CODE(parent_info->type)),
+                                               ZSTR_VAL(ce->parent->name));
+                               }
+                       } else if (UNEXPECTED(ZEND_TYPE_IS_SET(child_info->type) && !ZEND_TYPE_IS_SET(parent_info->type))) {
+                               zend_error_noreturn(E_COMPILE_ERROR,
+                                               "Type of %s::$%s must not be defined (as in class %s)",
+                                               ZSTR_VAL(ce->name),
+                                               ZSTR_VAL(key),
+                                               ZSTR_VAL(ce->parent->name));
+                       }
                }
        } else {
                if (UNEXPECTED(ce->type & ZEND_INTERNAL_CLASS)) {
@@ -773,6 +846,42 @@ static void do_inherit_class_constant(zend_string *name, zend_class_constant *pa
 }
 /* }}} */
 
+void zend_build_properties_info_table(zend_class_entry *ce)
+{
+       zend_property_info **table, *prop;
+       if (ce->default_properties_count == 0) {
+               return;
+       }
+
+       ZEND_ASSERT(ce->properties_info_table == NULL);
+       if (ce->type == ZEND_USER_CLASS) {
+               ce->properties_info_table = table = zend_arena_alloc(&CG(arena),
+                       sizeof(zend_property_info *) * ce->default_properties_count);
+       } else {
+               ce->properties_info_table = table = pemalloc(
+                       sizeof(zend_property_info *) * ce->default_properties_count, 1);
+       }
+
+       if (ce->parent && ce->parent->default_properties_count != 0) {
+               zend_property_info **parent_table = ce->parent->properties_info_table;
+               memcpy(
+                       table, parent_table,
+                       sizeof(zend_property_info *) * ce->parent->default_properties_count
+               );
+
+               /* Child did not add any new properties, we are done */
+               if (ce->default_properties_count == ce->parent->default_properties_count) {
+                       return;
+               }
+       }
+
+       ZEND_HASH_FOREACH_PTR(&ce->properties_info, prop) {
+               if (prop->ce == ce && (prop->flags & ZEND_ACC_STATIC) == 0) {
+                       table[OBJ_PROP_TO_NUM(prop->offset)] = prop;
+               }
+       } ZEND_HASH_FOREACH_END();
+}
+
 ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent_ce) /* {{{ */
 {
        zend_property_info *property_info;
@@ -998,7 +1107,7 @@ ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent
                        ce->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS;
                }
        }
-       ce->ce_flags |= parent_ce->ce_flags & (ZEND_HAS_STATIC_IN_METHODS | ZEND_ACC_USE_GUARDS);
+       ce->ce_flags |= parent_ce->ce_flags & (ZEND_HAS_STATIC_IN_METHODS | ZEND_ACC_HAS_TYPE_HINTS | ZEND_ACC_USE_GUARDS);
 }
 /* }}} */
 
@@ -1653,7 +1762,9 @@ static void zend_do_traits_property_binding(zend_class_entry *ce, zend_class_ent
                                        not_compatible = 1;
 
                                        if ((coliding_prop->flags & (ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC))
-                                               == (flags & (ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC))) {
+                                               == (flags & (ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC)) &&
+                                               property_types_compatible(property_info, coliding_prop)
+                                       ) {
                                                /* the flags are identical, thus, the properties may be compatible */
                                                zval *op1, *op2;
                                                zval op1_tmp, op2_tmp;
@@ -1714,9 +1825,7 @@ static void zend_do_traits_property_binding(zend_class_entry *ce, zend_class_ent
 
                        Z_TRY_ADDREF_P(prop_value);
                        doc_comment = property_info->doc_comment ? zend_string_copy(property_info->doc_comment) : NULL;
-                       zend_declare_property_ex(ce, prop_name,
-                                                                        prop_value, flags,
-                                                                    doc_comment);
+                       zend_declare_typed_property(ce, prop_name, prop_value, flags, doc_comment, property_info->type);
                        zend_string_release_ex(prop_name, 0);
                } ZEND_HASH_FOREACH_END();
        }
@@ -1930,6 +2039,8 @@ ZEND_API void zend_do_link_class(zend_class_entry *ce, zend_class_entry *parent)
        if ((ce->ce_flags & (ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_INTERFACE|ZEND_ACC_TRAIT|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) == ZEND_ACC_IMPLICIT_ABSTRACT_CLASS) {
                zend_verify_abstract_class(ce);
        }
+
+       zend_build_properties_info_table(ce);
 }
 /* }}} */
 

diff --git a/Zend/zend_inheritance.h b/Zend/zend_inheritance.h
index bda628fc294750a030b788e7616538de86ded959..a882f6461f069ac0fa21d68294f096723da28977 100644 (file)
--- a/Zend/zend_inheritance.h
+++ b/Zend/zend_inheritance.h
@@ -31,6 +31,7 @@ ZEND_API void zend_do_link_class(zend_class_entry *ce, zend_class_entry *parent_
 
 void zend_verify_abstract_class(zend_class_entry *ce);
 void zend_check_deprecated_constructor(const zend_class_entry *ce);
+void zend_build_properties_info_table(zend_class_entry *ce);
 
 END_EXTERN_C()
 

diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y
index ec9ba82193346ce0bb144b57e7848832ad0a77a6..c1902303c28d6230534eacd2cd565e40a980f66f 100644 (file)
--- a/Zend/zend_language_parser.y
+++ b/Zend/zend_language_parser.y
@@ -716,8 +716,9 @@ class_statement_list:
 
 
 class_statement:
-               variable_modifiers property_list ';'
-                       { $$ = $2; $$->attr = $1; }
+               variable_modifiers optional_type property_list ';'
+                       { $$ = zend_ast_create(ZEND_AST_PROP_GROUP, $2, $3);
+                         $$->attr = $1; }
        |       method_modifiers T_CONST class_const_list ';'
                        { $$ = $3; $$->attr = $1; }
        |       T_USE name_list trait_adaptations

diff --git a/Zend/zend_object_handlers.c b/Zend/zend_object_handlers.c
index 5f7e8195314649510dd0baad2f03591e75c3180c..e91202669be56367e81097ed939db776e4fd49b7 100644 (file)
--- a/Zend/zend_object_handlers.c
+++ b/Zend/zend_object_handlers.c
@@ -395,6 +395,7 @@ static zend_always_inline uintptr_t zend_get_property_offset(zend_class_entry *c
 dynamic:
                if (cache_slot) {
                        CACHE_POLYMORPHIC_PTR_EX(cache_slot, ce, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                       CACHE_PTR_EX(cache_slot + 2, NULL);
                }
                return ZEND_DYNAMIC_PROPERTY_OFFSET;
        }
@@ -450,6 +451,7 @@ found:
        }
        if (cache_slot) {
                CACHE_POLYMORPHIC_PTR_EX(cache_slot, ce, (void*)(uintptr_t)property_info->offset);
+               CACHE_PTR_EX(cache_slot + 2, property_info->type ? property_info : NULL);
        }
        return property_info->offset;
 }
@@ -627,12 +629,22 @@ ZEND_API uint32_t *zend_get_property_guard(zend_object *zobj, zend_string *membe
 }
 /* }}} */
 
+static zend_always_inline zend_property_info *prop_info_for_offset(
+               zend_object *obj, uint32_t prop_offset, void **cache_slot) {
+       if (cache_slot) {
+               return cache_slot[2];
+       } else {
+               return zend_get_typed_property_info_for_slot(obj, OBJ_PROP(obj, prop_offset));
+       }
+}
+
 ZEND_API zval *zend_std_read_property(zval *object, zval *member, int type, void **cache_slot, zval *rv) /* {{{ */
 {
        zend_object *zobj;
        zend_string *name, *tmp_name;
        zval *retval;
        uintptr_t property_offset;
+       zend_property_info *prop_info;
        uint32_t *guard = NULL;
 
        zobj = Z_OBJ_P(object);
@@ -737,6 +749,14 @@ call_getter:
                        } else {
                                retval = &EG(uninitialized_zval);
                        }
+
+                       if (UNEXPECTED(ZEND_CLASS_HAS_TYPE_HINTS(zobj->ce) &&
+                               IS_VALID_PROPERTY_OFFSET(property_offset) &&
+                               (prop_info = prop_info_for_offset(Z_OBJ_P(object), property_offset, cache_slot)))
+                       ) {
+                               zend_verify_prop_assignable_by_ref(prop_info, retval, (zobj->ce->__get->common.fn_flags & ZEND_ACC_STRICT_TYPES) != 0);
+                       }
+
                        OBJ_RELEASE(zobj);
                        goto exit;
                } else if (UNEXPECTED(IS_WRONG_PROPERTY_OFFSET(property_offset))) {
@@ -748,8 +768,15 @@ call_getter:
                }
        }
 
-       if ((type != BP_VAR_IS)) {
-               zend_error(E_NOTICE,"Undefined property: %s::$%s", ZSTR_VAL(zobj->ce->name), ZSTR_VAL(name));
+       if (type != BP_VAR_IS) {
+               if (IS_VALID_PROPERTY_OFFSET(property_offset) &&
+                       (prop_info = prop_info_for_offset(Z_OBJ_P(object), property_offset, cache_slot))) {
+                       zend_throw_error(NULL, "Typed property %s::$%s must not be accessed before initialization",
+                               ZSTR_VAL(prop_info->ce->name),
+                               ZSTR_VAL(name));
+               } else {
+                       zend_error(E_NOTICE,"Undefined property: %s::$%s", ZSTR_VAL(zobj->ce->name), ZSTR_VAL(name));
+               }
        }
        retval = &EG(uninitialized_zval);
 
@@ -760,11 +787,11 @@ exit:
 }
 /* }}} */
 
-ZEND_API void zend_std_write_property(zval *object, zval *member, zval *value, void **cache_slot) /* {{{ */
+ZEND_API zval *zend_std_write_property(zval *object, zval *member, zval *value, void **cache_slot) /* {{{ */
 {
        zend_object *zobj;
        zend_string *name, *tmp_name;
-       zval *variable_ptr;
+       zval *variable_ptr, tmp;
        uintptr_t property_offset;
        ZEND_ASSERT(!Z_ISREF_P(value));
 
@@ -776,7 +803,23 @@ ZEND_API void zend_std_write_property(zval *object, zval *member, zval *value, v
        if (EXPECTED(IS_VALID_PROPERTY_OFFSET(property_offset))) {
                variable_ptr = OBJ_PROP(zobj, property_offset);
                if (Z_TYPE_P(variable_ptr) != IS_UNDEF) {
-                       goto found;
+                       zend_property_info *prop_info = prop_info_for_offset(Z_OBJ_P(object), property_offset, cache_slot);
+
+                       Z_TRY_ADDREF_P(value);
+
+                       if (UNEXPECTED(prop_info)) {
+                               ZVAL_COPY_VALUE(&tmp, value);
+                               if (UNEXPECTED(!zend_verify_property_type(prop_info, &tmp, EG(current_execute_data) && ZEND_CALL_USES_STRICT_TYPES(EG(current_execute_data))))) {
+                                       Z_TRY_DELREF_P(value);
+                                       variable_ptr = &EG(error_zval);
+                                       goto exit;
+                               }
+                               value = &tmp;
+                       }
+
+found:
+                       zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EG(current_execute_data) && ZEND_CALL_USES_STRICT_TYPES(EG(current_execute_data)));
+                       goto exit;
                }
        } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(property_offset))) {
                if (EXPECTED(zobj->properties != NULL)) {
@@ -787,12 +830,12 @@ ZEND_API void zend_std_write_property(zval *object, zval *member, zval *value, v
                                zobj->properties = zend_array_dup(zobj->properties);
                        }
                        if ((variable_ptr = zend_hash_find(zobj->properties, name)) != NULL) {
-found:
-                               zend_assign_to_variable(variable_ptr, value, IS_CV);
-                               goto exit;
+                               Z_TRY_ADDREF_P(value);
+                               goto found;
                        }
                }
        } else if (UNEXPECTED(EG(exception))) {
+               variable_ptr = &EG(error_zval);
                goto exit;
        }
 
@@ -800,18 +843,20 @@ found:
        if (zobj->ce->__set) {
                uint32_t *guard = zend_get_property_guard(zobj, name);
 
-           if (!((*guard) & IN_SET)) {
+               if (!((*guard) & IN_SET)) {
                        GC_ADDREF(zobj);
                        (*guard) |= IN_SET; /* prevent circular setting */
                        zend_std_call_setter(zobj, name, value);
                        (*guard) &= ~IN_SET;
                        OBJ_RELEASE(zobj);
+                       variable_ptr = value;
                } else if (EXPECTED(!IS_WRONG_PROPERTY_OFFSET(property_offset))) {
                        goto write_std_property;
                } else {
                        /* Trigger the correct error */
                        zend_get_property_offset(zobj->ce, name, 0, NULL);
                        ZEND_ASSERT(EG(exception));
+                       variable_ptr = &EG(error_zval);
                        goto exit;
                }
        } else {
@@ -819,17 +864,32 @@ found:
 write_std_property:
                Z_TRY_ADDREF_P(value);
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(property_offset))) {
-                       ZVAL_COPY_VALUE(OBJ_PROP(zobj, property_offset), value);
+                       zend_property_info *prop_info;
+
+                       variable_ptr = OBJ_PROP(zobj, property_offset);
+
+                       if (UNEXPECTED(prop_info = prop_info_for_offset(Z_OBJ_P(object), property_offset, cache_slot))) {
+                               ZVAL_COPY_VALUE(&tmp, value);
+                               if (UNEXPECTED(!zend_verify_property_type(prop_info, &tmp, ZEND_CALL_USES_STRICT_TYPES(EG(current_execute_data))))) {
+                                       zval_ptr_dtor(value);
+                                       goto exit;
+                               }
+                               value = &tmp;
+                               goto found; /* might have been updated via e.g. __toString() */
+                       }
+
+                       ZVAL_COPY_VALUE(variable_ptr, value);
                } else {
                        if (!zobj->properties) {
                                rebuild_object_properties(zobj);
                        }
-                       zend_hash_add_new(zobj->properties, name, value);
+                       variable_ptr = zend_hash_add_new(zobj->properties, name, value);
                }
        }
 
 exit:
        zend_tmp_string_release(tmp_name);
+       return variable_ptr;
 }
 /* }}} */
 
@@ -957,9 +1017,6 @@ ZEND_API zval *zend_std_get_property_ptr_ptr(zval *object, zval *member, int typ
                if (UNEXPECTED(Z_TYPE_P(retval) == IS_UNDEF)) {
                        if (EXPECTED(!zobj->ce->__get) ||
                            UNEXPECTED((*zend_get_property_guard(zobj, name)) & IN_GET)) {
-                               ZVAL_NULL(retval);
-                               /* Notice is thrown after creation of the property, to avoid EG(std_property_info)
-                                * being overwritten in an error handler. */
                                if (UNEXPECTED(type == BP_VAR_RW || type == BP_VAR_R)) {
                                        zend_error(E_NOTICE, "Undefined property: %s::$%s", ZSTR_VAL(zobj->ce->name), ZSTR_VAL(name));
                                }
@@ -1015,6 +1072,13 @@ ZEND_API void zend_std_unset_property(zval *object, zval *member, void **cache_s
                zval *slot = OBJ_PROP(zobj, property_offset);
 
                if (Z_TYPE_P(slot) != IS_UNDEF) {
+                       if (UNEXPECTED(Z_ISREF_P(slot)) &&
+                                       (ZEND_DEBUG || ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(slot)))) {
+                               zend_property_info *prop_info = zend_get_property_info_for_slot(zobj, slot);
+                               if (prop_info->type) {
+                                       ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(slot), prop_info);
+                               }
+                       }
                        zval_ptr_dtor(slot);
                        ZVAL_UNDEF(slot);
                        if (zobj->properties) {
@@ -1366,11 +1430,12 @@ ZEND_API void zend_class_init_statics(zend_class_entry *class_type) /* {{{ */
        zend_intenal_class_init_statics(class_type);
 } /* }}} */
 
-ZEND_API zval *zend_std_get_static_property(zend_class_entry *ce, zend_string *property_name, zend_bool silent) /* {{{ */
+ZEND_API zval *zend_std_get_static_property_with_info(zend_class_entry *ce, zend_string *property_name, int type, zend_property_info **property_info_ptr) /* {{{ */
 {
-       zend_property_info *property_info = zend_hash_find_ptr(&ce->properties_info, property_name);
-       zend_class_entry *scope;
        zval *ret;
+       zend_class_entry *scope;
+       zend_property_info *property_info = zend_hash_find_ptr(&ce->properties_info, property_name);
+       *property_info_ptr = property_info;
 
        if (UNEXPECTED(property_info == NULL)) {
                goto undeclared_property;
@@ -1385,7 +1450,7 @@ ZEND_API zval *zend_std_get_static_property(zend_class_entry *ce, zend_string *p
                if (property_info->ce != scope) {
                        if (UNEXPECTED(property_info->flags & ZEND_ACC_PRIVATE)
                         || UNEXPECTED(!is_protected_compatible_scope(property_info->ce, scope))) {
-                               if (!silent) {
+                               if (type != BP_VAR_IS) {
                                        zend_bad_property_access(property_info, ce, property_name);
                                }
                                return NULL;
@@ -1409,7 +1474,7 @@ ZEND_API zval *zend_std_get_static_property(zend_class_entry *ce, zend_string *p
                        zend_intenal_class_init_statics(ce);
                } else {
 undeclared_property:
-                       if (!silent) {
+                       if (type != BP_VAR_IS) {
                                zend_throw_error(NULL, "Access to undeclared static property: %s::$%s", ZSTR_VAL(ce->name), ZSTR_VAL(property_name));
                        }
                        return NULL;
@@ -1418,10 +1483,25 @@ undeclared_property:
 
        ret = CE_STATIC_MEMBERS(ce) + property_info->offset;
        ZVAL_DEINDIRECT(ret);
+
+       if (UNEXPECTED((type == BP_VAR_R || type == BP_VAR_RW)
+                               && Z_TYPE_P(ret) == IS_UNDEF && property_info->type != 0)) {
+               zend_throw_error(NULL, "Typed static property %s::$%s must not be accessed before initialization",
+                       ZSTR_VAL(property_info->ce->name),
+                       zend_get_unmangled_property_name(property_name));
+               return NULL;
+       }
+
        return ret;
 }
 /* }}} */
 
+ZEND_API zval *zend_std_get_static_property(zend_class_entry *ce, zend_string *property_name, int type) /* {{{ */
+{
+       zend_property_info *prop_info;
+       return zend_std_get_static_property_with_info(ce, property_name, type, &prop_info);
+}
+
 ZEND_API ZEND_COLD zend_bool zend_std_unset_static_property(zend_class_entry *ce, zend_string *property_name) /* {{{ */
 {
        zend_throw_error(NULL, "Attempt to unset static property %s::$%s", ZSTR_VAL(ce->name), ZSTR_VAL(property_name));

diff --git a/Zend/zend_object_handlers.h b/Zend/zend_object_handlers.h
index fbb66f798ac6a7bcb0051dba5ad234d51fa466b1..c3b5fda42ddac116cb521bd1455bc74adf3a6315 100644 (file)
--- a/Zend/zend_object_handlers.h
+++ b/Zend/zend_object_handlers.h
@@ -51,9 +51,10 @@ typedef zval *(*zend_object_read_dimension_t)(zval *object, zval *offset, int ty
    If you receive a value zval in write_property/write_dimension, you may only modify it if
    its reference count is 1.  Otherwise, you must create a copy of that zval before making
    any changes.  You should NOT modify the reference count of the value passed to you.
+   You must return the final value of the assigned property.
 */
 /* Used to set property of the object */
-typedef void (*zend_object_write_property_t)(zval *object, zval *member, zval *value, void **cache_slot);
+typedef zval *(*zend_object_write_property_t)(zval *object, zval *member, zval *value, void **cache_slot);
 
 /* Used to set dimension of the object */
 typedef void (*zend_object_write_dimension_t)(zval *object, zval *offset, zval *value);
@@ -199,7 +200,8 @@ extern const ZEND_API zend_object_handlers std_object_handlers;
 
 ZEND_API void zend_class_init_statics(zend_class_entry *ce);
 ZEND_API zend_function *zend_std_get_static_method(zend_class_entry *ce, zend_string *function_name_strval, const zval *key);
-ZEND_API zval *zend_std_get_static_property(zend_class_entry *ce, zend_string *property_name, zend_bool silent);
+ZEND_API zval *zend_std_get_static_property_with_info(zend_class_entry *ce, zend_string *property_name, int type, struct _zend_property_info **prop_info);
+ZEND_API zval *zend_std_get_static_property(zend_class_entry *ce, zend_string *property_name, int type);
 ZEND_API ZEND_COLD zend_bool zend_std_unset_static_property(zend_class_entry *ce, zend_string *property_name);
 ZEND_API zend_function *zend_std_get_constructor(zend_object *object);
 ZEND_API struct _zend_property_info *zend_get_property_info(zend_class_entry *ce, zend_string *member, int silent);
@@ -209,7 +211,7 @@ ZEND_API HashTable *zend_std_get_debug_info(zval *object, int *is_temp);
 ZEND_API int zend_std_cast_object_tostring(zval *readobj, zval *writeobj, int type);
 ZEND_API zval *zend_std_get_property_ptr_ptr(zval *object, zval *member, int type, void **cache_slot);
 ZEND_API zval *zend_std_read_property(zval *object, zval *member, int type, void **cache_slot, zval *rv);
-ZEND_API void zend_std_write_property(zval *object, zval *member, zval *value, void **cache_slot);
+ZEND_API zval *zend_std_write_property(zval *object, zval *member, zval *value, void **cache_slot);
 ZEND_API int zend_std_has_property(zval *object, zval *member, int has_set_exists, void **cache_slot);
 ZEND_API void zend_std_unset_property(zval *object, zval *member, void **cache_slot);
 ZEND_API zval *zend_std_read_dimension(zval *object, zval *offset, int type, zval *rv);

diff --git a/Zend/zend_objects.c b/Zend/zend_objects.c
index 0051ce84383a7c7679ead16a4ca04784d88bcd44..19d17dc9e950baccb12f9f2a8e6a3f645bf0480d 100644 (file)
--- a/Zend/zend_objects.c
+++ b/Zend/zend_objects.c
@@ -57,7 +57,16 @@ ZEND_API void zend_object_std_dtor(zend_object *object)
        if (EXPECTED(object->ce->default_properties_count)) {
                end = p + object->ce->default_properties_count;
                do {
-                       i_zval_ptr_dtor(p);
+                       if (Z_REFCOUNTED_P(p)) {
+                               if (UNEXPECTED(Z_ISREF_P(p)) &&
+                                               (ZEND_DEBUG || ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(p)))) {
+                                       zend_property_info *prop_info = zend_get_property_info_for_slot(object, p);
+                                       if (prop_info->type) {
+                                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(p), prop_info);
+                                       }
+                               }
+                               i_zval_ptr_dtor(p);
+                       }
                        p++;
                } while (p != end);
        }
@@ -195,6 +204,13 @@ ZEND_API void ZEND_FASTCALL zend_objects_clone_members(zend_object *new_object,
                        i_zval_ptr_dtor(dst);
                        ZVAL_COPY_VALUE(dst, src);
                        zval_add_ref(dst);
+                       if (UNEXPECTED(Z_ISREF_P(dst)) &&
+                                       (ZEND_DEBUG || ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(dst)))) {
+                               zend_property_info *prop_info = zend_get_property_info_for_slot(new_object, dst);
+                               if (prop_info->type) {
+                                       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(dst), prop_info);
+                               }
+                       }
                        src++;
                        dst++;
                } while (src != end);

diff --git a/Zend/zend_objects_API.h b/Zend/zend_objects_API.h
index 658c8407cf873429a0e2e143c967a4ab8e676232..2a569604fc839dbabc74310b8c6277c299de101f 100644 (file)
--- a/Zend/zend_objects_API.h
+++ b/Zend/zend_objects_API.h
@@ -95,6 +95,24 @@ static zend_always_inline void *zend_object_alloc(size_t obj_size, zend_class_en
        return obj;
 }
 
+static inline zend_property_info *zend_get_property_info_for_slot(zend_object *obj, zval *slot)
+{
+       zend_property_info **table = obj->ce->properties_info_table;
+       intptr_t prop_num = slot - obj->properties_table;
+       ZEND_ASSERT(prop_num >= 0 && prop_num < obj->ce->default_properties_count);
+       return table[prop_num];
+}
+
+/* Helper for cases where we're only interested in property info of typed properties. */
+static inline zend_property_info *zend_get_typed_property_info_for_slot(zend_object *obj, zval *slot)
+{
+       zend_property_info *prop_info = zend_get_property_info_for_slot(obj, slot);
+       if (prop_info && prop_info->type) {
+               return prop_info;
+       }
+       return NULL;
+}
+
 
 #endif /* ZEND_OBJECTS_H */
 

diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c
index 6ec0e2d1c88195d6dc05f68ad723295aaae9e532..ec624a5adb8480a8d407e9fabff2cc9b040b9ca9 100644 (file)
--- a/Zend/zend_opcode.c
+++ b/Zend/zend_opcode.c
@@ -148,6 +148,15 @@ ZEND_API void zend_cleanup_internal_class_data(zend_class_entry *ce)
 
                ZEND_MAP_PTR_SET(ce->static_members_table, NULL);
                while (p != end) {
+                       if (UNEXPECTED(Z_ISREF_P(p))) {
+                               zend_property_info *prop_info;
+                               ZEND_REF_FOREACH_TYPE_SOURCES(Z_REF_P(p), prop_info) {
+                                       if (prop_info->ce == ce && p - static_members == prop_info->offset) {
+                                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(p), prop_info);
+                                               break; /* stop iteration here, the array might be realloc()'ed */
+                                       }
+                               } ZEND_REF_FOREACH_TYPE_SOURCES_END();
+                       }
                        i_zval_ptr_dtor(p);
                        p++;
                }
@@ -247,6 +256,15 @@ ZEND_API void destroy_zend_class(zval *zv)
                                zval *end = p + ce->default_static_members_count;
 
                                while (p != end) {
+                                       if (UNEXPECTED(Z_ISREF_P(p))) {
+                                               zend_property_info *prop_info;
+                                               ZEND_REF_FOREACH_TYPE_SOURCES(Z_REF_P(p), prop_info) {
+                                                       if (prop_info->ce == ce && p - ce->default_static_members_table == prop_info->offset) {
+                                                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(p), prop_info);
+                                                               break; /* stop iteration here, the array might be realloc()'ed */
+                                                       }
+                                               } ZEND_REF_FOREACH_TYPE_SOURCES_END();
+                                       }
                                        i_zval_ptr_dtor(p);
                                        p++;
                                }
@@ -258,6 +276,9 @@ ZEND_API void destroy_zend_class(zval *zv)
                                        if (prop_info->doc_comment) {
                                                zend_string_release_ex(prop_info->doc_comment, 0);
                                        }
+                                       if (ZEND_TYPE_IS_NAME(prop_info->type)) {
+                                               zend_string_release(ZEND_TYPE_NAME(prop_info->type));
+                                       }
                                }
                        } ZEND_HASH_FOREACH_END();
                        zend_hash_destroy(&ce->properties_info);
@@ -353,6 +374,9 @@ ZEND_API void destroy_zend_class(zval *zv)
                        if (ce->num_interfaces > 0) {
                                free(ce->interfaces);
                        }
+                       if (ce->properties_info_table) {
+                               free(ce->properties_info_table);
+                       }
                        free(ce);
                        break;
        }

diff --git a/Zend/zend_types.h b/Zend/zend_types.h
index ece1bdd90026828d8725d9875b9b22eb1bcbbad9..f2b089631aaf2d7d47ed039ed5936ac79ff043ba 100644 (file)
--- a/Zend/zend_types.h
+++ b/Zend/zend_types.h
@@ -108,6 +108,8 @@ typedef void (*copy_ctor_func_t)(zval *pElement);
  * ZEND_TYPE_IS_SET()     - checks if type-hint exists
  * ZEND_TYPE_IS_CODE()    - checks if type-hint refer to standard type
  * ZEND_TYPE_IS_CLASS()   - checks if type-hint refer to some class
+ * ZEND_TYPE_IS_CE()      - checks if type-hint refer to some class by zend_class_entry *
+ * ZEND_TYPE_IS_NAME()    - checks if type-hint refer to some class by zend_string *
  *
  * ZEND_TYPE_NAME()       - returns referenced class name
  * ZEND_TYPE_CE()         - returns referenced class entry
@@ -122,13 +124,19 @@ typedef void (*copy_ctor_func_t)(zval *pElement);
 typedef uintptr_t zend_type;
 
 #define ZEND_TYPE_IS_SET(t) \
-       ((t) > Z_L(1))
+       ((t) > Z_L(0x3))
 
 #define ZEND_TYPE_IS_CODE(t) \
-       (((t) > Z_L(1)) && ((t) <= Z_L(0x1ff)))
+       (((t) > Z_L(0x3)) && ((t) <= Z_L(0x3ff)))
 
 #define ZEND_TYPE_IS_CLASS(t) \
-       ((t) > Z_L(0x1ff))
+       ((t) > Z_L(0x3ff))
+
+#define ZEND_TYPE_IS_CE(t) \
+       (((t) & Z_L(0x2)) != 0)
+
+#define ZEND_TYPE_IS_NAME(t) \
+       (ZEND_TYPE_IS_CLASS(t) && !ZEND_TYPE_IS_CE(t))
 
 #define ZEND_TYPE_NAME(t) \
        ((zend_string*)((t) & ~Z_L(0x3)))
@@ -137,16 +145,22 @@ typedef uintptr_t zend_type;
        ((zend_class_entry*)((t) & ~Z_L(0x3)))
 
 #define ZEND_TYPE_CODE(t) \
-       ((t) >> Z_L(1))
+       ((t) >> Z_L(2))
 
 #define ZEND_TYPE_ALLOW_NULL(t) \
        (((t) & Z_L(0x1)) != 0)
 
+#define ZEND_TYPE_WITHOUT_NULL(t) \
+       ((t) & ~Z_L(0x1))
+
 #define ZEND_TYPE_ENCODE(code, allow_null) \
-       (((code) << Z_L(1)) | ((allow_null) ? Z_L(0x1) : Z_L(0x0)))
+       (((code) << Z_L(2)) | ((allow_null) ? Z_L(0x1) : Z_L(0x0)))
+
+#define ZEND_TYPE_ENCODE_CE(ce, allow_null) \
+       (((uintptr_t)(ce)) | ((allow_null) ? Z_L(0x3) : Z_L(0x2)))
 
 #define ZEND_TYPE_ENCODE_CLASS(class_name, allow_null) \
-       (((uintptr_t)(class_name)) | ((allow_null) ? Z_L(0x1) : Z_L(0)))
+       (((uintptr_t)(class_name)) | ((allow_null) ? Z_L(0x1) : Z_L(0x0)))
 
 #define ZEND_TYPE_ENCODE_CLASS_CONST_0(class_name) \
        ((zend_type) class_name)
@@ -369,9 +383,27 @@ struct _zend_resource {
        void             *ptr;
 };
 
+typedef struct _zend_property_info zend_property_info;
+
+typedef struct {
+       size_t num;
+       size_t num_allocated;
+       zend_property_info *ptr[1];
+} zend_property_info_list;
+
+typedef union {
+       zend_property_info *ptr;
+       uintptr_t list;
+} zend_property_info_source_list;
+
+#define ZEND_PROPERTY_INFO_SOURCE_FROM_LIST(list) (0x1 | (uintptr_t) (list))
+#define ZEND_PROPERTY_INFO_SOURCE_TO_LIST(list) ((zend_property_info_list *) ((list) & ~0x1))
+#define ZEND_PROPERTY_INFO_SOURCE_IS_LIST(list) ((list) & 0x1)
+
 struct _zend_reference {
-       zend_refcounted_h gc;
-       zval              val;
+       zend_refcounted_h              gc;
+       zval                           val;
+       zend_property_info_source_list sources;
 };
 
 struct _zend_ast_ref {
@@ -861,6 +893,7 @@ static zend_always_inline uint32_t zval_gc_info(uint32_t gc_type_info) {
                (zend_reference *) emalloc(sizeof(zend_reference));             \
                GC_SET_REFCOUNT(_ref, 1);                                                               \
                GC_TYPE_INFO(_ref) = IS_REFERENCE;                                              \
+               _ref->sources.ptr = NULL;                                                                       \
                Z_REF_P(z) = _ref;                                                                              \
                Z_TYPE_INFO_P(z) = IS_REFERENCE_EX;                                             \
        } while (0)
@@ -871,6 +904,7 @@ static zend_always_inline uint32_t zval_gc_info(uint32_t gc_type_info) {
                GC_SET_REFCOUNT(_ref, 1);                                                               \
                GC_TYPE_INFO(_ref) = IS_REFERENCE;                                              \
                ZVAL_COPY_VALUE(&_ref->val, r);                                                 \
+               _ref->sources.ptr = NULL;                                                                       \
                Z_REF_P(z) = _ref;                                                                              \
                Z_TYPE_INFO_P(z) = IS_REFERENCE_EX;                                             \
        } while (0)
@@ -882,6 +916,7 @@ static zend_always_inline uint32_t zval_gc_info(uint32_t gc_type_info) {
                GC_SET_REFCOUNT(_ref, (refcount));                                              \
                GC_TYPE_INFO(_ref) = IS_REFERENCE;                                              \
                ZVAL_COPY_VALUE(&_ref->val, _z);                                                \
+               _ref->sources.ptr = NULL;                                                                       \
                Z_REF_P(_z) = _ref;                                                                             \
                Z_TYPE_INFO_P(_z) = IS_REFERENCE_EX;                                    \
        } while (0)
@@ -893,6 +928,7 @@ static zend_always_inline uint32_t zval_gc_info(uint32_t gc_type_info) {
                GC_TYPE_INFO(_ref) = IS_REFERENCE |                                             \
                        (GC_PERSISTENT << GC_FLAGS_SHIFT);                                      \
                ZVAL_COPY_VALUE(&_ref->val, r);                                                 \
+               _ref->sources.ptr = NULL;                                                                       \
                Z_REF_P(z) = _ref;                                                                              \
                Z_TYPE_INFO_P(z) = IS_REFERENCE_EX;                                             \
        } while (0)

diff --git a/Zend/zend_variables.c b/Zend/zend_variables.c
index c057390700fbd7669d118e1f8f4ed5f2364f7e81..d6e72362435ac87eed75125fa25f046f8711f511 100644 (file)
--- a/Zend/zend_variables.c
+++ b/Zend/zend_variables.c
@@ -70,6 +70,7 @@ static void ZEND_FASTCALL zend_string_destroy(zend_string *str)
 
 static void ZEND_FASTCALL zend_reference_destroy(zend_reference *ref)
 {
+       ZEND_ASSERT(!ZEND_REF_HAS_TYPE_SOURCES(ref));
        i_zval_ptr_dtor(&ref->val);
        efree_size(ref, sizeof(zend_reference));
 }

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index f78b961c721510ba8035c9f115641d3d880ebdcc..22844ccc621467e510b4878f77515378194508d0 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -794,11 +794,13 @@ ZEND_VM_COLD_HELPER(zend_undefined_function_helper, ANY, ANY)
 ZEND_VM_HELPER(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMPVAR|CV, binary_op_type binary_op)
 {
        USE_OPLINE
-       zend_free_op free_op1, free_op2, free_op_data1;
+       zend_free_op free_op1, free_op2, free_op_data;
        zval *object;
        zval *property;
        zval *value;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
@@ -810,47 +812,126 @@ ZEND_VM_HELPER(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMPVAR|CV,
        property = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
        do {
-               value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
+               value = GET_OP_DATA_ZVAL_PTR(BP_VAR_R);
 
                if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       ZEND_VM_C_GOTO(assign_op_object);
-                               }
+                               ZEND_VM_C_GOTO(assign_op_object);
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 ZEND_VM_C_LABEL(assign_op_object):
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = (OP2_TYPE == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        } else {
-                               ZVAL_DEREF(zptr);
+                               zval *orig_zptr = zptr;
+                               zend_reference *ref;
+                               zend_bool is_typed_ref = 0;
+
+                               if (UNEXPECTED(Z_ISREF_P(zptr))) {
+                                       ref = Z_REF_P(zptr);
+                                       is_typed_ref = ZEND_REF_HAS_TYPE_SOURCES(ref);
+                                       zptr = Z_REFVAL_P(zptr);
+                               }
+
+                               if (OP2_TYPE == IS_CONST) {
+                                       prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
+                               } else {
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
+                               }
+                               if (UNEXPECTED(prop_info || is_typed_ref)) {
+                                       /* special case for typed properties */
+                                       zval z_copy;
+
+                                       binary_op(&z_copy, zptr, value);
+                                       if (EXPECTED(is_typed_ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(zptr);
+                                               ZVAL_COPY_VALUE(zptr, &z_copy);
+                                       } else {
+                                               zval_ptr_dtor(&z_copy);
+                                       }
+                               } else {
+                                       binary_op(zptr, zptr, value);
+                               }
 
-                               binary_op(zptr, zptr, value);
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), zptr);
                                }
                        }
                } else {
-                       zend_assign_op_overloaded_property(object, property, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL), value, binary_op OPLINE_CC EXECUTE_DATA_CC);
+                       zend_assign_op_overloaded_property(object, property, cache_slot, value, binary_op OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
-       FREE_OP(free_op_data1);
+       FREE_OP_DATA();
        FREE_OP2();
        FREE_OP1_VAR_PTR();
        /* assign_obj has two opcodes! */
        ZEND_VM_NEXT_OPCODE_EX(1, 2);
 }
 
+ZEND_VM_HELPER(zend_binary_assign_op_static_prop_helper, CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR, binary_op_type binary_op)
+{
+       /* This helper actually never will receive IS_VAR as second op, and has the same handling for VAR and TMP in the first op, but for interoperability with the other binary_assign_op helpers, it is necessary to "include" it */
+
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zend_reference *ref;
+       zend_bool is_typed_ref = 0;
+
+       SAVE_OPLINE();
+
+       if (UNEXPECTED(zend_fetch_static_property_address(&prop, &prop_info, (opline+1)->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
+               ZEND_ASSERT(EG(exception));
+               UNDEF_RESULT();
+               FREE_UNFETCHED_OP_DATA();
+               HANDLE_EXCEPTION();
+       }
+
+       value = GET_OP_DATA_ZVAL_PTR(BP_VAR_R);
+
+       if (UNEXPECTED(Z_ISREF_P(prop))) {
+               ref = Z_REF_P(prop);
+               is_typed_ref = ZEND_REF_HAS_TYPE_SOURCES(ref);
+               prop = Z_REFVAL_P(prop);
+       }
+
+       if (UNEXPECTED(prop_info->type || is_typed_ref)) {
+               /* special case for typed properties */
+               zval z_copy;
+
+               binary_op(&z_copy, prop, value);
+               if (EXPECTED(is_typed_ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(prop);
+                       ZVAL_COPY_VALUE(prop, &z_copy);
+               } else {
+                       zval_ptr_dtor(&z_copy);
+               }
+       } else {
+               binary_op(prop, prop, value);
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+       }
+
+       FREE_OP_DATA();
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 ZEND_VM_HELPER(zend_binary_assign_op_dim_helper, VAR|CV, CONST|TMPVAR|UNUSED|CV, binary_op_type binary_op)
 {
        USE_OPLINE
@@ -881,12 +962,32 @@ ZEND_VM_C_LABEL(assign_dim_op_new_array):
                        if (UNEXPECTED(!var_ptr)) {
                                ZEND_VM_C_GOTO(assign_dim_op_ret_null);
                        }
-                       ZVAL_DEREF(var_ptr);
                }
 
                value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
-               binary_op(var_ptr, var_ptr, value);
+               if (OP2_TYPE != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
+                       zend_reference *ref = Z_REF_P(var_ptr);
+                       var_ptr = Z_REFVAL_P(var_ptr);
+                       if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                               zval tmp;
+                               binary_op(&tmp, var_ptr, value);
+                               if (EXPECTED(zend_verify_ref_assignable_zval(ref, &tmp, EX_USES_STRICT_TYPES()))) {
+                                       zval_ptr_dtor(var_ptr);
+                                       ZVAL_COPY_VALUE(var_ptr, &tmp);
+                               } else {
+                                       zval_ptr_dtor(&tmp);
+                                       FREE_OP2();
+                                       FREE_OP(free_op_data1);
+                                       FREE_OP1_VAR_PTR();
+                                       HANDLE_EXCEPTION();
+                               }
+                       } else {
+                               binary_op(var_ptr, var_ptr, value);
+                       }
+               } else {
+                       binary_op(var_ptr, var_ptr, value);
+               }
 
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -958,9 +1059,25 @@ ZEND_VM_HELPER(zend_binary_assign_op_simple_helper, VAR|CV, CONST|TMPVAR|CV, bin
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               ZVAL_DEREF(var_ptr);
+               zend_reference *ref = NULL;
+               if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+                       ref = Z_REF_P(var_ptr);
+                       var_ptr = Z_REFVAL_P(var_ptr);
+               }
 
-               binary_op(var_ptr, var_ptr, value);
+               if (UNEXPECTED(ref && ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                       zval tmp;
+                       binary_op(&tmp, var_ptr, value);
+
+                       if (UNEXPECTED(zend_verify_ref_assignable_zval(ref, &tmp, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(var_ptr);
+                               ZVAL_COPY_VALUE(var_ptr, &tmp);
+                       } else {
+                               zval_ptr_dtor(&tmp);
+                       }
+               } else {
+                       binary_op(var_ptr, var_ptr, value);
+               }
 
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -972,10 +1089,16 @@ ZEND_VM_HELPER(zend_binary_assign_op_simple_helper, VAR|CV, CONST|TMPVAR|CV, bin
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-ZEND_VM_INLINE_HELPER(zend_binary_assign_op_helper, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, SPEC(DIM_OBJ), binary_op_type binary_op)
+ZEND_VM_INLINE_HELPER(zend_binary_assign_op_helper, CONST|TMP|VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, SPEC(DIM_OBJ), binary_op_type binary_op)
 {
-#if defined(ZEND_VM_SPEC) && OP2_TYPE == IS_UNUSED
-       ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_dim_helper, binary_op, binary_op);
+#if defined(ZEND_VM_SPEC) && (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR)
+       ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_static_prop_helper, binary_op, binary_op);
+#elif defined(ZEND_VM_SPEC) && (OP2_TYPE == IS_UNUSED)
+       if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+               ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_dim_helper, binary_op, binary_op);
+       }
+
+       ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_static_prop_helper, binary_op, binary_op);
 #else
 # if !defined(ZEND_VM_SPEC) || OP1_TYPE != IS_UNUSED
 #  if !defined(ZEND_VM_SPEC)
@@ -989,68 +1112,73 @@ ZEND_VM_INLINE_HELPER(zend_binary_assign_op_helper, VAR|UNUSED|THIS|CV, CONST|TM
        if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
                ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_dim_helper, binary_op, binary_op);
        }
+#  if !defined(ZEND_VM_SPEC) || OP2_TYPE == IS_CONST || OP2_TYPE == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(opline->extended_value == ZEND_ASSIGN_STATIC_PROP)) {
+               ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_static_prop_helper, binary_op, binary_op);
+       }
+#  endif
 # endif
 
        ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_obj_helper, binary_op, binary_op);
 #endif
 }
 
-ZEND_VM_HANDLER(23, ZEND_ASSIGN_ADD, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
+ZEND_VM_HANDLER(23, ZEND_ASSIGN_ADD, CONST|TMP|VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
 {
        ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_helper, binary_op, add_function);
 }
 
-ZEND_VM_HANDLER(24, ZEND_ASSIGN_SUB, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
+ZEND_VM_HANDLER(24, ZEND_ASSIGN_SUB, CONST|TMP|VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
 {
        ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_helper, binary_op, sub_function);
 }
 
-ZEND_VM_HANDLER(25, ZEND_ASSIGN_MUL, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
+ZEND_VM_HANDLER(25, ZEND_ASSIGN_MUL, CONST|TMP|VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
 {
        ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_helper, binary_op, mul_function);
 }
 
-ZEND_VM_HANDLER(26, ZEND_ASSIGN_DIV, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
+ZEND_VM_HANDLER(26, ZEND_ASSIGN_DIV, CONST|TMP|VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
 {
        ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_helper, binary_op, div_function);
 }
 
-ZEND_VM_HANDLER(27, ZEND_ASSIGN_MOD, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
+ZEND_VM_HANDLER(27, ZEND_ASSIGN_MOD, CONST|TMP|VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
 {
        ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_helper, binary_op, mod_function);
 }
 
-ZEND_VM_HANDLER(28, ZEND_ASSIGN_SL, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
+ZEND_VM_HANDLER(28, ZEND_ASSIGN_SL, CONST|TMP|VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
 {
        ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_helper, binary_op, shift_left_function);
 }
 
-ZEND_VM_HANDLER(29, ZEND_ASSIGN_SR, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
+ZEND_VM_HANDLER(29, ZEND_ASSIGN_SR, CONST|TMP|VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
 {
        ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_helper, binary_op, shift_right_function);
 }
 
-ZEND_VM_HANDLER(30, ZEND_ASSIGN_CONCAT, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
+ZEND_VM_HANDLER(30, ZEND_ASSIGN_CONCAT, CONST|TMP|VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
 {
        ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_helper, binary_op, concat_function);
 }
 
-ZEND_VM_HANDLER(31, ZEND_ASSIGN_BW_OR, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
+ZEND_VM_HANDLER(31, ZEND_ASSIGN_BW_OR, CONST|TMP|VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
 {
        ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_helper, binary_op, bitwise_or_function);
 }
 
-ZEND_VM_HANDLER(32, ZEND_ASSIGN_BW_AND, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
+ZEND_VM_HANDLER(32, ZEND_ASSIGN_BW_AND, CONST|TMP|VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
 {
        ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_helper, binary_op, bitwise_and_function);
 }
 
-ZEND_VM_HANDLER(33, ZEND_ASSIGN_BW_XOR, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
+ZEND_VM_HANDLER(33, ZEND_ASSIGN_BW_XOR, CONST|TMP|VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
 {
        ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_helper, binary_op, bitwise_xor_function);
 }
 
-ZEND_VM_HANDLER(167, ZEND_ASSIGN_POW, VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
+ZEND_VM_HANDLER(167, ZEND_ASSIGN_POW, CONST|TMP|VAR|UNUSED|THIS|CV, CONST|TMPVAR|UNUSED|NEXT|CV, DIM_OBJ|CACHE_SLOT, SPEC(DIM_OBJ))
 {
        ZEND_VM_DISPATCH_TO_HELPER(zend_binary_assign_op_helper, binary_op, pow_function);
 }
@@ -1062,6 +1190,8 @@ ZEND_VM_HELPER(zend_pre_incdec_property_helper, VAR|UNUSED|CV, CONST|TMPVAR|CV,
        zval *object;
        zval *property;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
@@ -1074,46 +1204,34 @@ ZEND_VM_HELPER(zend_pre_incdec_property_helper, VAR|UNUSED|CV, CONST|TMPVAR|CV,
 
        do {
                if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       ZEND_VM_C_GOTO(pre_incdec_object);
-                               }
+                               ZEND_VM_C_GOTO(pre_incdec_object);
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 ZEND_VM_C_LABEL(pre_incdec_object):
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = (OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        } else {
-                               if (EXPECTED(Z_TYPE_P(zptr) == IS_LONG)) {
-                                       if (inc) {
-                                               fast_long_increment_function(zptr);
-                                       } else {
-                                               fast_long_decrement_function(zptr);
-                                       }
+                               if (OP2_TYPE == IS_CONST) {
+                                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
                                } else {
-                                       ZVAL_DEREF(zptr);
-
-                                       if (inc) {
-                                               increment_function(zptr);
-                                       } else {
-                                               decrement_function(zptr);
-                                       }
-                               }
-                               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                                       ZVAL_COPY(EX_VAR(opline->result.var), zptr);
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
                                }
+                               zend_pre_incdec_property_zval(zptr, prop_info, inc OPLINE_CC EXECUTE_DATA_CC);
                        }
                } else {
-                       zend_pre_incdec_overloaded_property(object, property, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc OPLINE_CC EXECUTE_DATA_CC);
+                       zend_pre_incdec_overloaded_property(object, property, cache_slot, inc OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
@@ -1139,6 +1257,8 @@ ZEND_VM_HELPER(zend_post_incdec_property_helper, VAR|UNUSED|CV, CONST|TMPVAR|CV,
        zval *object;
        zval *property;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
@@ -1151,42 +1271,33 @@ ZEND_VM_HELPER(zend_post_incdec_property_helper, VAR|UNUSED|CV, CONST|TMPVAR|CV,
 
        do {
                if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       ZEND_VM_C_GOTO(post_incdec_object);
-                               }
+                               ZEND_VM_C_GOTO(post_incdec_object);
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 ZEND_VM_C_LABEL(post_incdec_object):
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = (OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
                        } else {
-                               if (EXPECTED(Z_TYPE_P(zptr) == IS_LONG)) {
-                                       ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(zptr));
-                                       if (inc) {
-                                               fast_long_increment_function(zptr);
-                                       } else {
-                                               fast_long_decrement_function(zptr);
-                                       }
+                               if (OP2_TYPE == IS_CONST) {
+                                       prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
                                } else {
-                                       ZVAL_DEREF(zptr);
-                                       ZVAL_COPY(EX_VAR(opline->result.var), zptr);
-                                       if (inc) {
-                                               increment_function(zptr);
-                                       } else {
-                                               decrement_function(zptr);
-                                       }
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
                                }
+
+                               zend_post_incdec_property_zval(zptr, prop_info, inc OPLINE_CC EXECUTE_DATA_CC);
                        }
                } else {
-                       zend_post_incdec_overloaded_property(object, property, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc OPLINE_CC EXECUTE_DATA_CC);
+                       zend_post_incdec_overloaded_property(object, property, cache_slot, inc OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
@@ -1205,6 +1316,62 @@ ZEND_VM_HANDLER(135, ZEND_POST_DEC_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CAC
        ZEND_VM_DISPATCH_TO_HELPER(zend_post_incdec_property_helper, inc, 0);
 }
 
+ZEND_VM_HELPER(zend_pre_incdec_static_property_helper, CONST|TMPVAR|CV, UNUSED|CONST|VAR, int inc)
+{
+       USE_OPLINE
+       zval *prop;
+       zend_property_info *prop_info;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       zend_pre_incdec_property_zval(prop, prop_info->type ? prop_info : NULL, inc OPLINE_CC EXECUTE_DATA_CC);
+
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
+ZEND_VM_HANDLER(203, ZEND_PRE_INC_STATIC_PROP, CONST|TMPVAR|CV, UNUSED|CONST|VAR, CACHE_SLOT)
+{
+       ZEND_VM_DISPATCH_TO_HELPER(zend_pre_incdec_static_property_helper, inc, 1);
+}
+
+ZEND_VM_HANDLER(204, ZEND_PRE_DEC_STATIC_PROP, CONST|TMPVAR|CV, UNUSED|CONST|VAR, CACHE_SLOT)
+{
+       ZEND_VM_DISPATCH_TO_HELPER(zend_pre_incdec_static_property_helper, inc, 0);
+}
+
+ZEND_VM_HELPER(zend_post_incdec_static_property_helper, CONST|TMPVAR|CV, UNUSED|CONST|VAR, int inc)
+{
+       USE_OPLINE
+       zval *prop;
+       zend_property_info *prop_info;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       zend_post_incdec_property_zval(prop, prop_info->type ? prop_info : NULL, inc OPLINE_CC EXECUTE_DATA_CC);
+
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
+ZEND_VM_HANDLER(205, ZEND_POST_INC_STATIC_PROP, CONST|TMPVAR|CV, UNUSED|CONST|VAR, CACHE_SLOT)
+{
+       ZEND_VM_DISPATCH_TO_HELPER(zend_post_incdec_static_property_helper, inc, 1);
+}
+
+ZEND_VM_HANDLER(206, ZEND_POST_DEC_STATIC_PROP, CONST|TMPVAR|CV, UNUSED|CONST|VAR, CACHE_SLOT)
+{
+       ZEND_VM_DISPATCH_TO_HELPER(zend_post_incdec_static_property_helper, inc, 0);
+}
+
 ZEND_VM_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY, SPEC(RETVAL))
 {
        USE_OPLINE
@@ -1233,9 +1400,35 @@ ZEND_VM_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY, SPEC(RETVAL))
                ZVAL_NULL(var_ptr);
                ZVAL_UNDEFINED_OP1();
        }
-       ZVAL_DEREF(var_ptr);
 
-       increment_function(var_ptr);
+       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+               zend_reference *ref = Z_REF_P(var_ptr);
+               var_ptr = Z_REFVAL_P(var_ptr);
+               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                       zval old;
+                       ZVAL_COPY(&old, var_ptr);
+
+                       increment_function(var_ptr);
+
+                       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_DOUBLE) && Z_TYPE(old) == IS_LONG) {
+                               zend_throw_incdec_ref_error(ref, 1);
+                               ZVAL_COPY_VALUE(var_ptr, &old);
+                               FREE_OP1_VAR_PTR();
+                               HANDLE_EXCEPTION();
+                       } else if (UNEXPECTED(!zend_verify_ref_assignable_zval(ref, var_ptr, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(var_ptr);
+                               ZVAL_COPY_VALUE(var_ptr, &old);
+                               FREE_OP1_VAR_PTR();
+                               HANDLE_EXCEPTION();
+                       } else {
+                               zval_ptr_dtor(&old);
+                       }
+               } else {
+                       increment_function(var_ptr);
+               }
+       } else {
+               increment_function(var_ptr);
+       }
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -1273,9 +1466,36 @@ ZEND_VM_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY, SPEC(RETVAL))
                ZVAL_NULL(var_ptr);             
                ZVAL_UNDEFINED_OP1();
        }
-       ZVAL_DEREF(var_ptr);
 
-       decrement_function(var_ptr);
+       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+               zend_reference *ref = Z_REF_P(var_ptr);
+               var_ptr = Z_REFVAL_P(var_ptr);
+
+               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                       zval old;
+                       ZVAL_COPY(&old, var_ptr);
+
+                       decrement_function(var_ptr);
+
+                       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_DOUBLE) && Z_TYPE(old) == IS_LONG) {
+                               zend_throw_incdec_ref_error(ref, 0);
+                               ZVAL_COPY_VALUE(var_ptr, &old);
+                               FREE_OP1_VAR_PTR();
+                               HANDLE_EXCEPTION();
+                       } else if (UNEXPECTED(!zend_verify_ref_assignable_zval(ref, var_ptr, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(var_ptr);
+                               ZVAL_COPY_VALUE(var_ptr, &old);
+                               FREE_OP1_VAR_PTR();
+                               HANDLE_EXCEPTION();
+                       } else {
+                               zval_ptr_dtor(&old);
+                       }
+               } else {
+                       decrement_function(var_ptr);
+               }
+       } else {
+               decrement_function(var_ptr);
+       }
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -1309,10 +1529,29 @@ ZEND_VM_HANDLER(36, ZEND_POST_INC, VAR|CV, ANY)
                ZVAL_NULL(var_ptr);
                ZVAL_UNDEFINED_OP1();
        }
-       ZVAL_DEREF(var_ptr);
-       ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 
-       increment_function(var_ptr);
+       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+               zend_reference *ref = Z_REF_P(var_ptr);
+               var_ptr = Z_REFVAL_P(var_ptr);
+
+               ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+
+               increment_function(var_ptr);
+
+               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_DOUBLE) && Z_TYPE_P(EX_VAR(opline->result.var)) == IS_LONG) {
+                               zend_throw_incdec_ref_error(ref, 1);
+                               ZVAL_COPY_VALUE(var_ptr, EX_VAR(opline->result.var));
+                       } else if (UNEXPECTED(!zend_verify_ref_assignable_zval(ref, var_ptr, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(var_ptr);
+                               ZVAL_COPY_VALUE(var_ptr, EX_VAR(opline->result.var));
+                       }
+               }
+       } else {
+               ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+
+               increment_function(var_ptr);
+       }
 
        FREE_OP1_VAR_PTR();
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
@@ -1342,10 +1581,29 @@ ZEND_VM_HANDLER(37, ZEND_POST_DEC, VAR|CV, ANY)
                ZVAL_NULL(var_ptr);
                ZVAL_UNDEFINED_OP1();
        }
-       ZVAL_DEREF(var_ptr);
-       ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 
-       decrement_function(var_ptr);
+       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+               zend_reference *ref = Z_REF_P(var_ptr);
+               var_ptr = Z_REFVAL_P(var_ptr);
+
+               ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+
+               decrement_function(var_ptr);
+
+               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_DOUBLE) && Z_TYPE_P(EX_VAR(opline->result.var)) == IS_LONG) {
+                               zend_throw_incdec_ref_error(ref, 0);
+                               ZVAL_COPY_VALUE(var_ptr, EX_VAR(opline->result.var));
+                       } else if (UNEXPECTED(!zend_verify_ref_assignable_zval(ref, var_ptr, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(var_ptr);
+                               ZVAL_COPY_VALUE(var_ptr, EX_VAR(opline->result.var));
+                       }
+               }
+       } else {
+               ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+
+               decrement_function(var_ptr);
+       }
 
        FREE_OP1_VAR_PTR();
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
@@ -1503,92 +1761,24 @@ ZEND_VM_HANDLER(89, ZEND_FETCH_IS, CONST|TMPVAR|CV, UNUSED, VAR_FETCH)
 ZEND_VM_HELPER(zend_fetch_static_prop_helper, CONST|TMPVAR|CV, UNUSED|CONST|VAR, int type)
 {
        USE_OPLINE
-       zend_free_op free_op1;
-       zval *varname;
-       zval *retval;
-       zend_string *name, *tmp_name;
-       zend_class_entry *ce;
+       zval *prop;
 
        SAVE_OPLINE();
 
-       do {
-               if (OP2_TYPE == IS_CONST) {
-                       if (OP1_TYPE == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value)) != NULL)) {
-                               retval = CACHED_PTR(opline->extended_value + sizeof(void*));
-                               break;
-                       } else {
-                               zval *class_name = RT_CONSTANT(opline, opline->op2);
-
-                               if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value)) == NULL)) {
-                                       ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
-                                       if (UNEXPECTED(ce == NULL)) {
-                                               FREE_UNFETCHED_OP1();
-                                               retval = NULL;
-                                               break;
-                                       }
-                                       if (OP1_TYPE != IS_CONST) {
-                                               CACHE_PTR(opline->extended_value, ce);
-                                       }
-                               }
-                       }
-               } else {
-                       if (OP2_TYPE == IS_UNUSED) {
-                               ce = zend_fetch_class(NULL, opline->op2.num);
-                               if (UNEXPECTED(ce == NULL)) {
-                                       FREE_UNFETCHED_OP1();
-                                       retval = NULL;
-                                       break;
-                               }
-                       } else {
-                               ce = Z_CE_P(EX_VAR(opline->op2.var));
-                       }
-                       if (OP1_TYPE == IS_CONST &&
-                           EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
-                               retval = CACHED_PTR(opline->extended_value + sizeof(void*));
-                               break;
-                       }
-               }
-
-               varname = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
-               if (OP1_TYPE == IS_CONST) {
-                       name = Z_STR_P(varname);
-               } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
-                       name = Z_STR_P(varname);
-                       tmp_name = NULL;
-               } else {
-                       if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
-                               zval_undefined_cv(EX(opline)->op1.var EXECUTE_DATA_CC);
-                       }
-                       name = zval_get_tmp_string(varname, &tmp_name);
-               }
-
-               retval = zend_std_get_static_property(ce, name, type == BP_VAR_IS);
-
-               if (OP1_TYPE != IS_CONST) {
-                       zend_tmp_string_release(tmp_name);
-               }
-
-               if (OP1_TYPE == IS_CONST && EXPECTED(retval)) {
-                       CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, retval);
-               }
-
-               FREE_OP1();
-       } while (0);
-
-       if (UNEXPECTED(retval == NULL)) {
+       if (UNEXPECTED(zend_fetch_static_property_address(&prop, NULL, opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS, type, opline->extended_value & ZEND_FETCH_OBJ_FLAGS OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
                if (EG(exception)) {
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                } else {
                        ZEND_ASSERT(type == BP_VAR_IS);
-                       retval = &EG(uninitialized_zval);
+                       prop = &EG(uninitialized_zval);
                }
        }
 
        if (type == BP_VAR_R || type == BP_VAR_IS) {
-               ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
+               ZVAL_COPY_DEREF(EX_VAR(opline->result.var), prop);
        } else {
-               ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
+               ZVAL_INDIRECT(EX_VAR(opline->result.var), prop);
        }
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -1598,7 +1788,7 @@ ZEND_VM_HANDLER(173, ZEND_FETCH_STATIC_PROP_R, CONST|TMPVAR|CV, UNUSED|CLASS_FET
        ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_R);
 }
 
-ZEND_VM_HANDLER(174, ZEND_FETCH_STATIC_PROP_W, CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR, CACHE_SLOT)
+ZEND_VM_HANDLER(174, ZEND_FETCH_STATIC_PROP_W, CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR, FETCH_REF|DIM_OBJ_WRITE|CACHE_SLOT)
 {
        ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_W);
 }
@@ -1608,7 +1798,7 @@ ZEND_VM_HANDLER(175, ZEND_FETCH_STATIC_PROP_RW, CONST|TMPVAR|CV, UNUSED|CLASS_FE
        ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper, type, BP_VAR_RW);
 }
 
-ZEND_VM_HANDLER(177, ZEND_FETCH_STATIC_PROP_FUNC_ARG, CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR, CACHE_SLOT)
+ZEND_VM_HANDLER(177, ZEND_FETCH_STATIC_PROP_FUNC_ARG, CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR, FETCH_REF|CACHE_SLOT)
 {
        int fetch_type =
                (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ?
@@ -1811,7 +2001,7 @@ ZEND_VM_HOT_OBJ_HANDLER(82, ZEND_FETCH_OBJ_R, CONST|TMPVAR|UNUSED|THIS|CV, CONST
                zval *retval;
 
                if (OP2_TYPE == IS_CONST) {
-                       cache_slot = CACHE_ADDR(opline->extended_value);
+                       cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
                                uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
@@ -1867,7 +2057,7 @@ ZEND_VM_C_LABEL(fetch_obj_r_finish):
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-ZEND_VM_HANDLER(85, ZEND_FETCH_OBJ_W, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
+ZEND_VM_HANDLER(85, ZEND_FETCH_OBJ_W, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, FETCH_REF|DIM_OBJ_WRITE|CACHE_SLOT)
 {
        USE_OPLINE
        zend_free_op free_op1, free_op2;
@@ -1882,7 +2072,10 @@ ZEND_VM_HANDLER(85, ZEND_FETCH_OBJ_W, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE
 
        property = GET_OP2_ZVAL_PTR(BP_VAR_R);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_W OPLINE_CC);
+       zend_fetch_property_address(
+               result, container, OP1_TYPE, property, OP2_TYPE,
+               ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
+               BP_VAR_W, opline->extended_value & ZEND_FETCH_OBJ_FLAGS, 1 OPLINE_CC);
        FREE_OP2();
        if (OP1_TYPE == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -1904,7 +2097,7 @@ ZEND_VM_HANDLER(88, ZEND_FETCH_OBJ_RW, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACH
        }
        property = GET_OP2_ZVAL_PTR(BP_VAR_R);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW OPLINE_CC);
+       zend_fetch_property_address(result, container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, 1 OPLINE_CC);
        FREE_OP2();
        if (OP1_TYPE == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -2002,14 +2195,13 @@ ZEND_VM_C_LABEL(fetch_obj_is_finish):
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-ZEND_VM_COLD_CONST_HANDLER(94, ZEND_FETCH_OBJ_FUNC_ARG, CONST|TMP|VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
+ZEND_VM_COLD_CONST_HANDLER(94, ZEND_FETCH_OBJ_FUNC_ARG, CONST|TMP|VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, FETCH_REF|CACHE_SLOT)
 {
        if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
                /* Behave like FETCH_OBJ_W */
                if ((OP1_TYPE & (IS_CONST|IS_TMP_VAR))) {
                        ZEND_VM_DISPATCH_TO_HELPER(zend_use_tmp_in_write_context_helper);
                }
-
                ZEND_VM_DISPATCH_TO_HANDLER(ZEND_FETCH_OBJ_W);
        } else {
                ZEND_VM_DISPATCH_TO_HANDLER(ZEND_FETCH_OBJ_R);
@@ -2031,7 +2223,7 @@ ZEND_VM_HANDLER(97, ZEND_FETCH_OBJ_UNSET, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, C
 
        property = GET_OP2_ZVAL_PTR(BP_VAR_R);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET OPLINE_CC);
+       zend_fetch_property_address(result, container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, 1 OPLINE_CC);
        FREE_OP2();
        if (OP1_TYPE == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -2093,13 +2285,12 @@ ZEND_VM_HANDLER(136, ZEND_ASSIGN_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE
        value = GET_OP_DATA_ZVAL_PTR(BP_VAR_R);
 
        if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               ZEND_VM_C_GOTO(assign_object);
-                       }
+                       ZEND_VM_C_GOTO(assign_object);
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
                        FREE_OP_DATA();
                        ZEND_VM_C_GOTO(exit_assign_obj);
                }
@@ -2108,15 +2299,54 @@ ZEND_VM_HANDLER(136, ZEND_ASSIGN_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE
 ZEND_VM_C_LABEL(assign_object):
        if (OP2_TYPE == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((OP_DATA_TYPE & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((OP_DATA_TYPE & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((OP_DATA_TYPE & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+                                               FREE_OP2();
+                                               FREE_OP1_VAR_PTR();
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (OP_DATA_TYPE == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((OP_DATA_TYPE & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 ZEND_VM_C_LABEL(fast_assign_obj):
-                               value = zend_assign_to_variable(property_val, value, OP_DATA_TYPE);
+                                       value = zend_assign_to_variable(property_val, value, OP_DATA_TYPE, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -2178,10 +2408,10 @@ ZEND_VM_C_LABEL(fast_assign_obj):
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
        FREE_OP_DATA();
 ZEND_VM_C_LABEL(exit_assign_obj):
@@ -2191,18 +2421,74 @@ ZEND_VM_C_LABEL(exit_assign_obj):
        ZEND_VM_NEXT_OPCODE_EX(1, 2);
 }
 
+ZEND_VM_HANDLER(201, ZEND_ASSIGN_STATIC_PROP, CONST|TMPVAR|CV, UNUSED|CONST|VAR, CACHE_SLOT, SPEC(OP_DATA=CONST|TMP|VAR|CV))
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               FREE_UNFETCHED_OP_DATA();
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = GET_OP_DATA_ZVAL_PTR(BP_VAR_R);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((OP_DATA_TYPE & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((OP_DATA_TYPE & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((OP_DATA_TYPE & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((OP_DATA_TYPE & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, OP_DATA_TYPE, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 ZEND_VM_HANDLER(147, ZEND_ASSIGN_DIM, VAR|CV, CONST|TMPVAR|UNUSED|NEXT|CV, SPEC(OP_DATA=CONST|TMP|VAR|CV))
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op2, free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
+       orig_object_ptr = object_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 ZEND_VM_C_LABEL(try_assign_dim_array):
@@ -2244,7 +2530,7 @@ ZEND_VM_C_LABEL(try_assign_dim_array):
                                ZEND_VM_C_GOTO(assign_dim_error);
                        }
                        value = GET_OP_DATA_ZVAL_PTR(BP_VAR_R);
-                       value = zend_assign_to_variable(variable_ptr, value, OP_DATA_TYPE);
+                       value = zend_assign_to_variable(variable_ptr, value, OP_DATA_TYPE, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -2280,6 +2566,15 @@ ZEND_VM_C_LABEL(try_assign_dim_array):
                                FREE_OP_DATA();
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+                               FREE_UNFETCHED_OP2();
+                               FREE_UNFETCHED_OP_DATA();
+                               FREE_OP1_VAR_PTR();
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        ZEND_VM_C_GOTO(try_assign_dim_array);
                } else {
@@ -2319,7 +2614,7 @@ ZEND_VM_HANDLER(38, ZEND_ASSIGN, VAR|CV, CONST|TMP|VAR|CV, SPEC(RETVAL))
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               value = zend_assign_to_variable(variable_ptr, value, OP2_TYPE);
+               value = zend_assign_to_variable(variable_ptr, value, OP2_TYPE, EX_USES_STRICT_TYPES());
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -2346,7 +2641,7 @@ ZEND_VM_HANDLER(39, ZEND_ASSIGN_REF, VAR|CV, VAR|CV, SRC)
        } else if (OP1_TYPE == IS_VAR &&
                   UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
 
-               zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
+               zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
                FREE_OP1_VAR_PTR();
                FREE_OP2_VAR_PTR();
                UNDEF_RESULT();
@@ -2379,6 +2674,152 @@ ZEND_VM_HANDLER(39, ZEND_ASSIGN_REF, VAR|CV, VAR|CV, SRC)
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+ZEND_VM_HANDLER(200, ZEND_ASSIGN_OBJ_REF, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT|SRC, SPEC(OP_DATA=VAR|CV))
+{
+       USE_OPLINE
+       zend_free_op free_op1, free_op2, free_op_data;
+       zval *property;
+       zval *container;
+       zval variable, *variable_ptr = &variable;
+       zval *value_ptr;
+       void **cache_addr;
+
+       SAVE_OPLINE();
+
+       container = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
+
+       if (OP1_TYPE == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
+               ZEND_VM_DISPATCH_TO_HELPER(zend_this_not_in_object_context_helper);
+       }
+
+       property = GET_OP2_ZVAL_PTR(BP_VAR_R);
+
+       cache_addr = (OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
+
+       zend_fetch_property_address(variable_ptr, container, OP1_TYPE, property, OP2_TYPE, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC);
+       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
+               variable_ptr = Z_INDIRECT_P(variable_ptr);
+       }
+
+       value_ptr = GET_OP_DATA_ZVAL_PTR_PTR(BP_VAR_W);
+
+       if (UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (UNEXPECTED(Z_TYPE(variable) != IS_INDIRECT)) {
+               zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
+               FREE_OP1_VAR_PTR();
+               FREE_OP2();
+               FREE_OP_DATA_VAR_PTR();
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       } else if (OP_DATA_TYPE == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (OP_DATA_TYPE == IS_VAR &&
+                  opline->extended_value == ZEND_RETURNS_FUNCTION &&
+                          UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
+                               Z_INDIRECT_P(variable_ptr), value_ptr, OP2_TYPE OPLINE_CC EXECUTE_DATA_CC))) {
+                       FREE_OP1_VAR_PTR();
+                       FREE_OP2();
+                       FREE_OP_DATA_VAR_PTR();
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+               FREE_OP1_VAR_PTR();
+               FREE_OP2();
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               zend_property_info *prop_info = NULL;
+
+               if (OP2_TYPE == IS_CONST) {
+                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
+               } else {
+                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
+               }
+
+               if (UNEXPECTED(prop_info)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+                               FREE_OP1_VAR_PTR();
+                               FREE_OP2();
+                               FREE_OP_DATA_VAR_PTR();
+                               HANDLE_EXCEPTION();
+                       }
+
+                       if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr)) && Z_ISREF_P(variable_ptr)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+                       }
+               }
+               zend_assign_to_variable_reference(variable_ptr, value_ptr);
+               if (prop_info) {
+                       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               }
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+       }
+
+       FREE_OP1_VAR_PTR();
+       FREE_OP2();
+       FREE_OP_DATA_VAR_PTR();
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+ZEND_VM_HANDLER(202, ZEND_ASSIGN_STATIC_PROP_REF, CONST|TMPVAR|CV, UNUSED|CONST|VAR, CACHE_SLOT|SRC)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value_ptr;
+       zend_property_info *prop_info;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value & ~ZEND_RETURNS_FUNCTION, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               FREE_UNFETCHED_OP_DATA();
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value_ptr = GET_OP_DATA_ZVAL_PTR_PTR(BP_VAR_W);
+
+       if (OP_DATA_TYPE == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               prop = &EG(uninitialized_zval);
+       } else if (OP_DATA_TYPE == IS_VAR && (opline->extended_value & ZEND_RETURNS_FUNCTION) && UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(prop, value_ptr, OP2_TYPE OPLINE_CC EXECUTE_DATA_CC))) {
+                       FREE_OP_DATA_VAR_PTR();
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               if (UNEXPECTED(prop_info->type)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+                               FREE_OP_DATA_VAR_PTR();
+                               HANDLE_EXCEPTION();
+                       }
+                       if (UNEXPECTED(Z_REFCOUNTED_P(prop)) && Z_ISREF_P(prop)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(prop), prop_info);
+                       }
+               }
+       }
+       zend_assign_to_variable_reference(prop, value_ptr);
+       if (prop_info->type) {
+               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(prop), prop_info);
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+       }
+
+       FREE_OP_DATA_VAR_PTR();
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 ZEND_VM_HOT_HELPER(zend_leave_helper, ANY, ANY)
 {
        zend_execute_data *old_execute_data;
@@ -5921,7 +6362,7 @@ ZEND_VM_C_LABEL(fe_fetch_r_exit):
 
        if (EXPECTED(OP2_TYPE == IS_CV)) {
                zval *variable_ptr = EX_VAR(opline->op2.var);
-               zend_assign_to_variable(variable_ptr, value, IS_CV);
+               zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
        } else {
                zval *res = EX_VAR(opline->op2.var);
                zend_refcounted *gc = Z_COUNTED_P(value);
@@ -6004,6 +6445,15 @@ ZEND_VM_HANDLER(126, ZEND_FE_FETCH_RW, VAR, ANY, JMP_ADDR)
                                                value_type = Z_TYPE_INFO_P(value);
                                                if (EXPECTED(value_type != IS_UNDEF)
                                                 && EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key, 0) == SUCCESS)) {
+                                                       if ((value_type & Z_TYPE_MASK) != IS_REFERENCE) {
+                                                               zend_property_info *prop_info =
+                                                                       zend_get_typed_property_info_for_slot(Z_OBJ_P(array), value);
+                                                               if (UNEXPECTED(prop_info)) {
+                                                                       ZVAL_NEW_REF(value, value);
+                                                                       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(value), prop_info);
+                                                                       value_type = IS_REFERENCE_EX;
+                                                               }
+                                                       }
                                                        break;
                                                }
                                        } else if (EXPECTED(Z_OBJCE_P(array)->default_properties_count == 0)
@@ -6180,71 +6630,16 @@ ZEND_VM_HANDLER(180, ZEND_ISSET_ISEMPTY_STATIC_PROP, CONST|TMPVAR|CV, UNUSED|CLA
        USE_OPLINE
        zval *value;
        int result;
-       zend_free_op free_op1;
-       zval *varname;
-       zend_string *name, *tmp_name;
-       zend_class_entry *ce;
 
        SAVE_OPLINE();
-       if (OP2_TYPE == IS_CONST) {
-               if (OP1_TYPE == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY)) != NULL)) {
-                       value = CACHED_PTR((opline->extended_value & ~ZEND_ISEMPTY) + sizeof(void*));
-                       ZEND_VM_C_GOTO(is_static_prop_return);
-               } else if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY)) == NULL)) {
-                       ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
-                       if (UNEXPECTED(ce == NULL)) {
-                               ZEND_ASSERT(EG(exception));
-                               ZVAL_UNDEF(EX_VAR(opline->result.var));
-                               HANDLE_EXCEPTION();
-                       }
-                       if (OP1_TYPE != IS_CONST) {
-                               CACHE_PTR(opline->extended_value & ~ZEND_ISEMPTY, ce);
-                       }
-               }
-       } else {
-               if (OP2_TYPE == IS_UNUSED) {
-                       ce = zend_fetch_class(NULL, opline->op2.num);
-                       if (UNEXPECTED(ce == NULL)) {
-                               ZEND_ASSERT(EG(exception));
-                               FREE_UNFETCHED_OP1();
-                               ZVAL_UNDEF(EX_VAR(opline->result.var));
-                               HANDLE_EXCEPTION();
-                       }
-               } else {
-                       ce = Z_CE_P(EX_VAR(opline->op2.var));
-               }
-               if (OP1_TYPE == IS_CONST &&
-                   EXPECTED(CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY) == ce)) {
-
-                       value = CACHED_PTR((opline->extended_value & ~ZEND_ISEMPTY) + sizeof(void*));
-                       ZEND_VM_C_GOTO(is_static_prop_return);
-               }
-       }
-
-       varname = GET_OP1_ZVAL_PTR(BP_VAR_IS);
-       if (OP1_TYPE == IS_CONST) {
-               name = Z_STR_P(varname);
-       } else {
-               name = zval_get_tmp_string(varname, &tmp_name);
-       }
-
-       value = zend_std_get_static_property(ce, name, 1);
 
-       if (OP1_TYPE == IS_CONST && value) {
-               CACHE_POLYMORPHIC_PTR(opline->extended_value & ~ZEND_ISEMPTY, ce, value);
-       }
-
-       if (OP1_TYPE != IS_CONST) {
-               zend_tmp_string_release(tmp_name);
-       }
-       FREE_OP1();
+       result = zend_fetch_static_property_address(&value, NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0 OPLINE_CC EXECUTE_DATA_CC);
 
-ZEND_VM_C_LABEL(is_static_prop_return):
        if (!(opline->extended_value & ZEND_ISEMPTY)) {
-               result = value && Z_TYPE_P(value) > IS_NULL &&
+               result = result == SUCCESS && Z_TYPE_P(value) > IS_NULL &&
                    (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
        } else {
-               result = !value || !i_zend_is_true(value);
+               result = result != SUCCESS || !i_zend_is_true(value);
        }
 
        ZEND_VM_SMART_BRANCH(result, 1);
@@ -7811,6 +8206,7 @@ ZEND_VM_HANDLER(183, ZEND_BIND_STATIC, CV, UNUSED, REF)
                        GC_SET_REFCOUNT(ref, 2);
                        GC_TYPE_INFO(ref) = IS_REFERENCE;
                        ZVAL_COPY_VALUE(&ref->val, value);
+                       ref->sources.ptr = NULL;
                        Z_REF_P(value) = ref;
                        Z_TYPE_INFO_P(value) = IS_REFERENCE_EX;
                        ZVAL_REF(variable_ptr, ref);
@@ -8778,7 +9174,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_FE_FETCH_R, op->op2_type == IS_CV && (op1_inf
        }
 
        variable_ptr = EX_VAR(opline->op2.var);
-       zend_assign_to_variable(variable_ptr, value, IS_CV);
+       zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 790e01b8f3ab3200afab5ffde412e39465b48e4e..d24636c0f8117a52ce6a058b4b3b8ea70fc07ba1 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -4432,94 +4432,229 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CON
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_CONST_CONST(int type ZEND_OPCODE_HANDLER_ARGS_DC)
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_static_prop_helper_SPEC_CONST_CONST(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
-       USE_OPLINE
+       /* This helper actually never will receive IS_VAR as second op, and has the same handling for VAR and TMP in the first op, but for interoperability with the other binary_assign_op helpers, it is necessary to "include" it */
 
-       zval *varname;
-       zval *retval;
-       zend_string *name, *tmp_name;
-       zend_class_entry *ce;
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zend_reference *ref;
+       zend_bool is_typed_ref = 0;
 
        SAVE_OPLINE();
 
-       do {
-               if (IS_CONST == IS_CONST) {
-                       if (IS_CONST == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value)) != NULL)) {
-                               retval = CACHED_PTR(opline->extended_value + sizeof(void*));
-                               break;
-                       } else {
-                               zval *class_name = RT_CONSTANT(opline, opline->op2);
+       if (UNEXPECTED(zend_fetch_static_property_address(&prop, &prop_info, (opline+1)->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
+               ZEND_ASSERT(EG(exception));
+               UNDEF_RESULT();
+               FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
+               HANDLE_EXCEPTION();
+       }
 
-                               if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value)) == NULL)) {
-                                       ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
-                                       if (UNEXPECTED(ce == NULL)) {
+       value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data);
 
-                                               retval = NULL;
-                                               break;
-                                       }
-                                       if (IS_CONST != IS_CONST) {
-                                               CACHE_PTR(opline->extended_value, ce);
-                                       }
-                               }
-                       }
-               } else {
-                       if (IS_CONST == IS_UNUSED) {
-                               ce = zend_fetch_class(NULL, opline->op2.num);
-                               if (UNEXPECTED(ce == NULL)) {
+       if (UNEXPECTED(Z_ISREF_P(prop))) {
+               ref = Z_REF_P(prop);
+               is_typed_ref = ZEND_REF_HAS_TYPE_SOURCES(ref);
+               prop = Z_REFVAL_P(prop);
+       }
 
-                                       retval = NULL;
-                                       break;
-                               }
-                       } else {
-                               ce = Z_CE_P(EX_VAR(opline->op2.var));
-                       }
-                       if (IS_CONST == IS_CONST &&
-                           EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
-                               retval = CACHED_PTR(opline->extended_value + sizeof(void*));
-                               break;
-                       }
-               }
+       if (UNEXPECTED(prop_info->type || is_typed_ref)) {
+               /* special case for typed properties */
+               zval z_copy;
 
-               varname = RT_CONSTANT(opline, opline->op1);
-               if (IS_CONST == IS_CONST) {
-                       name = Z_STR_P(varname);
-               } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
-                       name = Z_STR_P(varname);
-                       tmp_name = NULL;
+               binary_op(&z_copy, prop, value);
+               if (EXPECTED(is_typed_ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(prop);
+                       ZVAL_COPY_VALUE(prop, &z_copy);
                } else {
-                       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
-                               zval_undefined_cv(EX(opline)->op1.var EXECUTE_DATA_CC);
-                       }
-                       name = zval_get_tmp_string(varname, &tmp_name);
+                       zval_ptr_dtor(&z_copy);
                }
+       } else {
+               binary_op(prop, prop, value);
+       }
 
-               retval = zend_std_get_static_property(ce, name, type == BP_VAR_IS);
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+       }
 
-               if (IS_CONST != IS_CONST) {
-                       zend_tmp_string_release(tmp_name);
-               }
+       FREE_OP(free_op_data);
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
 
-               if (IS_CONST == IS_CONST && EXPECTED(retval)) {
-                       CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, retval);
-               }
+static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_CONST_CONST_STATIC_PROP(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+#if 1 && (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CONST_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && (IS_CONST == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CONST_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
 
-       } while (0);
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CONST_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#else
+# if 0 || IS_CONST != IS_UNUSED
+#  if 0
+       /* opline->extended_value checks are specialized, don't need opline */
+       USE_OPLINE
+#  endif
+
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_simple_helper_SPEC_CONST_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CONST_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  if 0 || IS_CONST == IS_CONST || IS_CONST == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(1)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CONST_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
+# endif
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_CONST_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#endif
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CONST_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_CONST_STATIC_PROP(add_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CONST_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_CONST_STATIC_PROP(sub_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CONST_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_CONST_STATIC_PROP(mul_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CONST_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_CONST_STATIC_PROP(div_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CONST_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_CONST_STATIC_PROP(mod_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
 
-       if (UNEXPECTED(retval == NULL)) {
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CONST_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_CONST_STATIC_PROP(shift_left_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CONST_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_CONST_STATIC_PROP(shift_right_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CONST_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_CONST_STATIC_PROP(concat_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CONST_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_CONST_STATIC_PROP(bitwise_or_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CONST_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_CONST_STATIC_PROP(bitwise_and_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CONST_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_CONST_STATIC_PROP(bitwise_xor_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_CONST_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_CONST_STATIC_PROP(pow_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_static_property_helper_SPEC_CONST_CONST(int inc ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       USE_OPLINE
+       zval *prop;
+       zend_property_info *prop_info;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       zend_pre_incdec_property_zval(prop, prop_info->type ? prop_info : NULL, inc OPLINE_CC EXECUTE_DATA_CC);
+
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_pre_incdec_static_property_helper_SPEC_CONST_CONST(1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_pre_incdec_static_property_helper_SPEC_CONST_CONST(0 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_static_property_helper_SPEC_CONST_CONST(int inc ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       USE_OPLINE
+       zval *prop;
+       zend_property_info *prop_info;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       zend_post_incdec_property_zval(prop, prop_info->type ? prop_info : NULL, inc OPLINE_CC EXECUTE_DATA_CC);
+
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_STATIC_PROP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_post_incdec_static_property_helper_SPEC_CONST_CONST(1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_post_incdec_static_property_helper_SPEC_CONST_CONST(0 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_CONST_CONST(int type ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       USE_OPLINE
+       zval *prop;
+
+       SAVE_OPLINE();
+
+       if (UNEXPECTED(zend_fetch_static_property_address(&prop, NULL, opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS, type, opline->extended_value & ZEND_FETCH_OBJ_FLAGS OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
                if (EG(exception)) {
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                } else {
                        ZEND_ASSERT(type == BP_VAR_IS);
-                       retval = &EG(uninitialized_zval);
+                       prop = &EG(uninitialized_zval);
                }
        }
 
        if (type == BP_VAR_R || type == BP_VAR_IS) {
-               ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
+               ZVAL_COPY_DEREF(EX_VAR(opline->result.var), prop);
        } else {
-               ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
+               ZVAL_INDIRECT(EX_VAR(opline->result.var), prop);
        }
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -4667,7 +4802,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_
                zval *retval;
 
                if (IS_CONST == IS_CONST) {
-                       cache_slot = CACHE_ADDR(opline->extended_value);
+                       cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
                                uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
@@ -4820,7 +4955,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_AR
                if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
                        ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
                }
-
                ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
                ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -4840,6 +4974,282 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_LIST_R_SPEC_CONST_CONST_
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_CONST & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_CONST & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_CONST & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_CONST, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_TMP_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_TMP_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_TMP_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_VAR, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_CV & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_CV & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_CV & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_CV, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value_ptr;
+       zend_property_info *prop_info;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value & ~ZEND_RETURNS_FUNCTION, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value_ptr = get_zval_ptr_ptr((opline+1)->op1_type, (opline+1)->op1, &free_op_data, BP_VAR_W);
+
+       if ((opline+1)->op1_type == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               prop = &EG(uninitialized_zval);
+       } else if ((opline+1)->op1_type == IS_VAR && (opline->extended_value & ZEND_RETURNS_FUNCTION) && UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(prop, value_ptr, IS_CONST OPLINE_CC EXECUTE_DATA_CC))) {
+                       if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               if (UNEXPECTED(prop_info->type)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+                               if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+                               HANDLE_EXCEPTION();
+                       }
+                       if (UNEXPECTED(Z_REFCOUNTED_P(prop)) && Z_ISREF_P(prop)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(prop), prop_info);
+                       }
+               }
+       }
+       zend_assign_to_variable_reference(prop, value_ptr);
+       if (prop_info->type) {
+               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(prop), prop_info);
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+       }
+
+       if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -5548,69 +5958,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC
        zval *value;
        int result;
 
-       zval *varname;
-       zend_string *name, *tmp_name;
-       zend_class_entry *ce;
-
        SAVE_OPLINE();
-       if (IS_CONST == IS_CONST) {
-               if (IS_CONST == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY)) != NULL)) {
-                       value = CACHED_PTR((opline->extended_value & ~ZEND_ISEMPTY) + sizeof(void*));
-                       goto is_static_prop_return;
-               } else if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY)) == NULL)) {
-                       ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
-                       if (UNEXPECTED(ce == NULL)) {
-                               ZEND_ASSERT(EG(exception));
-                               ZVAL_UNDEF(EX_VAR(opline->result.var));
-                               HANDLE_EXCEPTION();
-                       }
-                       if (IS_CONST != IS_CONST) {
-                               CACHE_PTR(opline->extended_value & ~ZEND_ISEMPTY, ce);
-                       }
-               }
-       } else {
-               if (IS_CONST == IS_UNUSED) {
-                       ce = zend_fetch_class(NULL, opline->op2.num);
-                       if (UNEXPECTED(ce == NULL)) {
-                               ZEND_ASSERT(EG(exception));
 
-                               ZVAL_UNDEF(EX_VAR(opline->result.var));
-                               HANDLE_EXCEPTION();
-                       }
-               } else {
-                       ce = Z_CE_P(EX_VAR(opline->op2.var));
-               }
-               if (IS_CONST == IS_CONST &&
-                   EXPECTED(CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY) == ce)) {
-
-                       value = CACHED_PTR((opline->extended_value & ~ZEND_ISEMPTY) + sizeof(void*));
-                       goto is_static_prop_return;
-               }
-       }
-
-       varname = RT_CONSTANT(opline, opline->op1);
-       if (IS_CONST == IS_CONST) {
-               name = Z_STR_P(varname);
-       } else {
-               name = zval_get_tmp_string(varname, &tmp_name);
-       }
+       result = zend_fetch_static_property_address(&value, NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0 OPLINE_CC EXECUTE_DATA_CC);
 
-       value = zend_std_get_static_property(ce, name, 1);
-
-       if (IS_CONST == IS_CONST && value) {
-               CACHE_POLYMORPHIC_PTR(opline->extended_value & ~ZEND_ISEMPTY, ce, value);
-       }
-
-       if (IS_CONST != IS_CONST) {
-               zend_tmp_string_release(tmp_name);
-       }
-
-is_static_prop_return:
        if (!(opline->extended_value & ZEND_ISEMPTY)) {
-               result = value && Z_TYPE_P(value) > IS_NULL &&
+               result = result == SUCCESS && Z_TYPE_P(value) > IS_NULL &&
                    (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
        } else {
-               result = !value || !i_zend_is_true(value);
+               result = result != SUCCESS || !i_zend_is_true(value);
        }
 
        ZEND_VM_SMART_BRANCH(result, 1);
@@ -6749,6 +7105,152 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HA
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_static_prop_helper_SPEC_CONST_TMPVAR(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       /* This helper actually never will receive IS_VAR as second op, and has the same handling for VAR and TMP in the first op, but for interoperability with the other binary_assign_op helpers, it is necessary to "include" it */
+
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zend_reference *ref;
+       zend_bool is_typed_ref = 0;
+
+       SAVE_OPLINE();
+
+       if (UNEXPECTED(zend_fetch_static_property_address(&prop, &prop_info, (opline+1)->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
+               ZEND_ASSERT(EG(exception));
+               UNDEF_RESULT();
+               FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
+               HANDLE_EXCEPTION();
+       }
+
+       value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data);
+
+       if (UNEXPECTED(Z_ISREF_P(prop))) {
+               ref = Z_REF_P(prop);
+               is_typed_ref = ZEND_REF_HAS_TYPE_SOURCES(ref);
+               prop = Z_REFVAL_P(prop);
+       }
+
+       if (UNEXPECTED(prop_info->type || is_typed_ref)) {
+               /* special case for typed properties */
+               zval z_copy;
+
+               binary_op(&z_copy, prop, value);
+               if (EXPECTED(is_typed_ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(prop);
+                       ZVAL_COPY_VALUE(prop, &z_copy);
+               } else {
+                       zval_ptr_dtor(&z_copy);
+               }
+       } else {
+               binary_op(prop, prop, value);
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+       }
+
+       FREE_OP(free_op_data);
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_CONST_TMPVAR_STATIC_PROP(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+#if 1 && (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CONST_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && ((IS_TMP_VAR|IS_VAR) == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CONST_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CONST_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#else
+# if 0 || IS_CONST != IS_UNUSED
+#  if 0
+       /* opline->extended_value checks are specialized, don't need opline */
+       USE_OPLINE
+#  endif
+
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_simple_helper_SPEC_CONST_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CONST_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  if 0 || (IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(1)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CONST_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
+# endif
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_CONST_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#endif
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_TMPVAR_STATIC_PROP(add_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_TMPVAR_STATIC_PROP(sub_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_TMPVAR_STATIC_PROP(mul_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_TMPVAR_STATIC_PROP(div_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_TMPVAR_STATIC_PROP(mod_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_TMPVAR_STATIC_PROP(shift_left_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_TMPVAR_STATIC_PROP(shift_right_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_TMPVAR_STATIC_PROP(concat_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_TMPVAR_STATIC_PROP(bitwise_or_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_TMPVAR_STATIC_PROP(bitwise_and_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_TMPVAR_STATIC_PROP(bitwise_xor_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_TMPVAR_STATIC_PROP(pow_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -6859,7 +7361,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_
                zval *retval;
 
                if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-                       cache_slot = CACHE_ADDR(opline->extended_value);
+                       cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
                                uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
@@ -7012,7 +7514,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_AR
                if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
                        ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
                }
-
                ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
                ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -7897,94 +8398,83 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMP_HANDLER(Z
        ZEND_VM_RETURN();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_CONST_VAR(int type ZEND_OPCODE_HANDLER_ARGS_DC)
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_static_property_helper_SPEC_CONST_VAR(int inc ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
-
-       zval *varname;
-       zval *retval;
-       zend_string *name, *tmp_name;
-       zend_class_entry *ce;
+       zval *prop;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
 
-       do {
-               if (IS_VAR == IS_CONST) {
-                       if (IS_CONST == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value)) != NULL)) {
-                               retval = CACHED_PTR(opline->extended_value + sizeof(void*));
-                               break;
-                       } else {
-                               zval *class_name = RT_CONSTANT(opline, opline->op2);
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
 
-                               if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value)) == NULL)) {
-                                       ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
-                                       if (UNEXPECTED(ce == NULL)) {
+       zend_pre_incdec_property_zval(prop, prop_info->type ? prop_info : NULL, inc OPLINE_CC EXECUTE_DATA_CC);
 
-                                               retval = NULL;
-                                               break;
-                                       }
-                                       if (IS_CONST != IS_CONST) {
-                                               CACHE_PTR(opline->extended_value, ce);
-                                       }
-                               }
-                       }
-               } else {
-                       if (IS_VAR == IS_UNUSED) {
-                               ce = zend_fetch_class(NULL, opline->op2.num);
-                               if (UNEXPECTED(ce == NULL)) {
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
 
-                                       retval = NULL;
-                                       break;
-                               }
-                       } else {
-                               ce = Z_CE_P(EX_VAR(opline->op2.var));
-                       }
-                       if (IS_CONST == IS_CONST &&
-                           EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
-                               retval = CACHED_PTR(opline->extended_value + sizeof(void*));
-                               break;
-                       }
-               }
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_pre_incdec_static_property_helper_SPEC_CONST_VAR(1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
 
-               varname = RT_CONSTANT(opline, opline->op1);
-               if (IS_CONST == IS_CONST) {
-                       name = Z_STR_P(varname);
-               } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
-                       name = Z_STR_P(varname);
-                       tmp_name = NULL;
-               } else {
-                       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
-                               zval_undefined_cv(EX(opline)->op1.var EXECUTE_DATA_CC);
-                       }
-                       name = zval_get_tmp_string(varname, &tmp_name);
-               }
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_pre_incdec_static_property_helper_SPEC_CONST_VAR(0 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
 
-               retval = zend_std_get_static_property(ce, name, type == BP_VAR_IS);
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_static_property_helper_SPEC_CONST_VAR(int inc ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       USE_OPLINE
+       zval *prop;
+       zend_property_info *prop_info;
 
-               if (IS_CONST != IS_CONST) {
-                       zend_tmp_string_release(tmp_name);
-               }
+       SAVE_OPLINE();
 
-               if (IS_CONST == IS_CONST && EXPECTED(retval)) {
-                       CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, retval);
-               }
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
 
-       } while (0);
+       zend_post_incdec_property_zval(prop, prop_info->type ? prop_info : NULL, inc OPLINE_CC EXECUTE_DATA_CC);
+
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_STATIC_PROP_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_post_incdec_static_property_helper_SPEC_CONST_VAR(1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_post_incdec_static_property_helper_SPEC_CONST_VAR(0 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_CONST_VAR(int type ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       USE_OPLINE
+       zval *prop;
+
+       SAVE_OPLINE();
 
-       if (UNEXPECTED(retval == NULL)) {
+       if (UNEXPECTED(zend_fetch_static_property_address(&prop, NULL, opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS, type, opline->extended_value & ZEND_FETCH_OBJ_FLAGS OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
                if (EG(exception)) {
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                } else {
                        ZEND_ASSERT(type == BP_VAR_IS);
-                       retval = &EG(uninitialized_zval);
+                       prop = &EG(uninitialized_zval);
                }
        }
 
        if (type == BP_VAR_R || type == BP_VAR_IS) {
-               ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
+               ZVAL_COPY_DEREF(EX_VAR(opline->result.var), prop);
        } else {
-               ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
+               ZVAL_INDIRECT(EX_VAR(opline->result.var), prop);
        }
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -8022,6 +8512,282 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_IS_SPEC_CONS
        ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC_CONST_VAR(BP_VAR_IS ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_CONST & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_CONST & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_CONST & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_CONST, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_TMP_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_TMP_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_TMP_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_VAR, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_CV & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_CV & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_CV & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_CV, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value_ptr;
+       zend_property_info *prop_info;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value & ~ZEND_RETURNS_FUNCTION, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value_ptr = get_zval_ptr_ptr((opline+1)->op1_type, (opline+1)->op1, &free_op_data, BP_VAR_W);
+
+       if ((opline+1)->op1_type == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               prop = &EG(uninitialized_zval);
+       } else if ((opline+1)->op1_type == IS_VAR && (opline->extended_value & ZEND_RETURNS_FUNCTION) && UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(prop, value_ptr, IS_VAR OPLINE_CC EXECUTE_DATA_CC))) {
+                       if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               if (UNEXPECTED(prop_info->type)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+                               if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+                               HANDLE_EXCEPTION();
+                       }
+                       if (UNEXPECTED(Z_REFCOUNTED_P(prop)) && Z_ISREF_P(prop)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(prop), prop_info);
+                       }
+               }
+       }
+       zend_assign_to_variable_reference(prop, value_ptr);
+       if (prop_info->type) {
+               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(prop), prop_info);
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+       }
+
+       if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_STATIC_PROP_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -8082,69 +8848,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC
        zval *value;
        int result;
 
-       zval *varname;
-       zend_string *name, *tmp_name;
-       zend_class_entry *ce;
-
        SAVE_OPLINE();
-       if (IS_VAR == IS_CONST) {
-               if (IS_CONST == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY)) != NULL)) {
-                       value = CACHED_PTR((opline->extended_value & ~ZEND_ISEMPTY) + sizeof(void*));
-                       goto is_static_prop_return;
-               } else if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY)) == NULL)) {
-                       ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
-                       if (UNEXPECTED(ce == NULL)) {
-                               ZEND_ASSERT(EG(exception));
-                               ZVAL_UNDEF(EX_VAR(opline->result.var));
-                               HANDLE_EXCEPTION();
-                       }
-                       if (IS_CONST != IS_CONST) {
-                               CACHE_PTR(opline->extended_value & ~ZEND_ISEMPTY, ce);
-                       }
-               }
-       } else {
-               if (IS_VAR == IS_UNUSED) {
-                       ce = zend_fetch_class(NULL, opline->op2.num);
-                       if (UNEXPECTED(ce == NULL)) {
-                               ZEND_ASSERT(EG(exception));
-
-                               ZVAL_UNDEF(EX_VAR(opline->result.var));
-                               HANDLE_EXCEPTION();
-                       }
-               } else {
-                       ce = Z_CE_P(EX_VAR(opline->op2.var));
-               }
-               if (IS_CONST == IS_CONST &&
-                   EXPECTED(CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY) == ce)) {
-
-                       value = CACHED_PTR((opline->extended_value & ~ZEND_ISEMPTY) + sizeof(void*));
-                       goto is_static_prop_return;
-               }
-       }
-
-       varname = RT_CONSTANT(opline, opline->op1);
-       if (IS_CONST == IS_CONST) {
-               name = Z_STR_P(varname);
-       } else {
-               name = zval_get_tmp_string(varname, &tmp_name);
-       }
 
-       value = zend_std_get_static_property(ce, name, 1);
+       result = zend_fetch_static_property_address(&value, NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0 OPLINE_CC EXECUTE_DATA_CC);
 
-       if (IS_CONST == IS_CONST && value) {
-               CACHE_POLYMORPHIC_PTR(opline->extended_value & ~ZEND_ISEMPTY, ce, value);
-       }
-
-       if (IS_CONST != IS_CONST) {
-               zend_tmp_string_release(tmp_name);
-       }
-
-is_static_prop_return:
        if (!(opline->extended_value & ZEND_ISEMPTY)) {
-               result = value && Z_TYPE_P(value) > IS_NULL &&
+               result = result == SUCCESS && Z_TYPE_P(value) > IS_NULL &&
                    (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
        } else {
-               result = !value || !i_zend_is_true(value);
+               result = result != SUCCESS || !i_zend_is_true(value);
        }
 
        ZEND_VM_SMART_BRANCH(result, 1);
@@ -8289,6 +9001,208 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_VAR_HANDLER(Z
        ZEND_VM_RETURN();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_static_prop_helper_SPEC_CONST_UNUSED(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       /* This helper actually never will receive IS_VAR as second op, and has the same handling for VAR and TMP in the first op, but for interoperability with the other binary_assign_op helpers, it is necessary to "include" it */
+
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zend_reference *ref;
+       zend_bool is_typed_ref = 0;
+
+       SAVE_OPLINE();
+
+       if (UNEXPECTED(zend_fetch_static_property_address(&prop, &prop_info, (opline+1)->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
+               ZEND_ASSERT(EG(exception));
+               UNDEF_RESULT();
+               FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
+               HANDLE_EXCEPTION();
+       }
+
+       value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data);
+
+       if (UNEXPECTED(Z_ISREF_P(prop))) {
+               ref = Z_REF_P(prop);
+               is_typed_ref = ZEND_REF_HAS_TYPE_SOURCES(ref);
+               prop = Z_REFVAL_P(prop);
+       }
+
+       if (UNEXPECTED(prop_info->type || is_typed_ref)) {
+               /* special case for typed properties */
+               zval z_copy;
+
+               binary_op(&z_copy, prop, value);
+               if (EXPECTED(is_typed_ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(prop);
+                       ZVAL_COPY_VALUE(prop, &z_copy);
+               } else {
+                       zval_ptr_dtor(&z_copy);
+               }
+       } else {
+               binary_op(prop, prop, value);
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+       }
+
+       FREE_OP(free_op_data);
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_CONST_UNUSED_STATIC_PROP(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+#if 1 && (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CONST_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && (IS_UNUSED == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CONST_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CONST_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#else
+# if 0 || IS_CONST != IS_UNUSED
+#  if 0
+       /* opline->extended_value checks are specialized, don't need opline */
+       USE_OPLINE
+#  endif
+
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_simple_helper_SPEC_CONST_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CONST_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  if 0 || IS_UNUSED == IS_CONST || IS_UNUSED == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(1)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CONST_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
+# endif
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_CONST_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#endif
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_UNUSED_STATIC_PROP(add_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_UNUSED_STATIC_PROP(sub_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_UNUSED_STATIC_PROP(mul_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_UNUSED_STATIC_PROP(div_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_UNUSED_STATIC_PROP(mod_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_UNUSED_STATIC_PROP(shift_left_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_UNUSED_STATIC_PROP(shift_right_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_UNUSED_STATIC_PROP(concat_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_UNUSED_STATIC_PROP(bitwise_or_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_UNUSED_STATIC_PROP(bitwise_and_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_UNUSED_STATIC_PROP(bitwise_xor_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CONST_UNUSED_STATIC_PROP(pow_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_static_property_helper_SPEC_CONST_UNUSED(int inc ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       USE_OPLINE
+       zval *prop;
+       zend_property_info *prop_info;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       zend_pre_incdec_property_zval(prop, prop_info->type ? prop_info : NULL, inc OPLINE_CC EXECUTE_DATA_CC);
+
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_pre_incdec_static_property_helper_SPEC_CONST_UNUSED(1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_pre_incdec_static_property_helper_SPEC_CONST_UNUSED(0 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_static_property_helper_SPEC_CONST_UNUSED(int inc ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       USE_OPLINE
+       zval *prop;
+       zend_property_info *prop_info;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       zend_post_incdec_property_zval(prop, prop_info->type ? prop_info : NULL, inc OPLINE_CC EXECUTE_DATA_CC);
+
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_STATIC_PROP_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_post_incdec_static_property_helper_SPEC_CONST_UNUSED(1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_post_incdec_static_property_helper_SPEC_CONST_UNUSED(0 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
@@ -8411,91 +9325,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CONST_UNUSED_HAN
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_CONST_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
-
-       zval *varname;
-       zval *retval;
-       zend_string *name, *tmp_name;
-       zend_class_entry *ce;
+       zval *prop;
 
        SAVE_OPLINE();
 
-       do {
-               if (IS_UNUSED == IS_CONST) {
-                       if (IS_CONST == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value)) != NULL)) {
-                               retval = CACHED_PTR(opline->extended_value + sizeof(void*));
-                               break;
-                       } else {
-                               zval *class_name = RT_CONSTANT(opline, opline->op2);
-
-                               if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value)) == NULL)) {
-                                       ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
-                                       if (UNEXPECTED(ce == NULL)) {
-
-                                               retval = NULL;
-                                               break;
-                                       }
-                                       if (IS_CONST != IS_CONST) {
-                                               CACHE_PTR(opline->extended_value, ce);
-                                       }
-                               }
-                       }
-               } else {
-                       if (IS_UNUSED == IS_UNUSED) {
-                               ce = zend_fetch_class(NULL, opline->op2.num);
-                               if (UNEXPECTED(ce == NULL)) {
-
-                                       retval = NULL;
-                                       break;
-                               }
-                       } else {
-                               ce = Z_CE_P(EX_VAR(opline->op2.var));
-                       }
-                       if (IS_CONST == IS_CONST &&
-                           EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
-                               retval = CACHED_PTR(opline->extended_value + sizeof(void*));
-                               break;
-                       }
-               }
-
-               varname = RT_CONSTANT(opline, opline->op1);
-               if (IS_CONST == IS_CONST) {
-                       name = Z_STR_P(varname);
-               } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
-                       name = Z_STR_P(varname);
-                       tmp_name = NULL;
-               } else {
-                       if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
-                               zval_undefined_cv(EX(opline)->op1.var EXECUTE_DATA_CC);
-                       }
-                       name = zval_get_tmp_string(varname, &tmp_name);
-               }
-
-               retval = zend_std_get_static_property(ce, name, type == BP_VAR_IS);
-
-               if (IS_CONST != IS_CONST) {
-                       zend_tmp_string_release(tmp_name);
-               }
-
-               if (IS_CONST == IS_CONST && EXPECTED(retval)) {
-                       CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, retval);
-               }
-
-       } while (0);
-
-       if (UNEXPECTED(retval == NULL)) {
+       if (UNEXPECTED(zend_fetch_static_property_address(&prop, NULL, opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS, type, opline->extended_value & ZEND_FETCH_OBJ_FLAGS OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
                if (EG(exception)) {
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                } else {
                        ZEND_ASSERT(type == BP_VAR_IS);
-                       retval = &EG(uninitialized_zval);
+                       prop = &EG(uninitialized_zval);
                }
        }
 
        if (type == BP_VAR_R || type == BP_VAR_IS) {
-               ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
+               ZVAL_COPY_DEREF(EX_VAR(opline->result.var), prop);
        } else {
-               ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
+               ZVAL_INDIRECT(EX_VAR(opline->result.var), prop);
        }
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -8548,6 +9395,282 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_
        }
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_CONST & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_CONST & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_CONST & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_CONST, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_TMP_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_TMP_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_TMP_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_VAR, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_CV & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_CV & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_CV & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_CV, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value_ptr;
+       zend_property_info *prop_info;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value & ~ZEND_RETURNS_FUNCTION, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value_ptr = get_zval_ptr_ptr((opline+1)->op1_type, (opline+1)->op1, &free_op_data, BP_VAR_W);
+
+       if ((opline+1)->op1_type == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               prop = &EG(uninitialized_zval);
+       } else if ((opline+1)->op1_type == IS_VAR && (opline->extended_value & ZEND_RETURNS_FUNCTION) && UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(prop, value_ptr, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC))) {
+                       if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               if (UNEXPECTED(prop_info->type)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+                               if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+                               HANDLE_EXCEPTION();
+                       }
+                       if (UNEXPECTED(Z_REFCOUNTED_P(prop)) && Z_ISREF_P(prop)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(prop), prop_info);
+                       }
+               }
+       }
+       zend_assign_to_variable_reference(prop, value_ptr);
+       if (prop_info->type) {
+               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(prop), prop_info);
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+       }
+
+       if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -9064,69 +10187,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC
        zval *value;
        int result;
 
-       zval *varname;
-       zend_string *name, *tmp_name;
-       zend_class_entry *ce;
-
        SAVE_OPLINE();
-       if (IS_UNUSED == IS_CONST) {
-               if (IS_CONST == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY)) != NULL)) {
-                       value = CACHED_PTR((opline->extended_value & ~ZEND_ISEMPTY) + sizeof(void*));
-                       goto is_static_prop_return;
-               } else if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY)) == NULL)) {
-                       ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
-                       if (UNEXPECTED(ce == NULL)) {
-                               ZEND_ASSERT(EG(exception));
-                               ZVAL_UNDEF(EX_VAR(opline->result.var));
-                               HANDLE_EXCEPTION();
-                       }
-                       if (IS_CONST != IS_CONST) {
-                               CACHE_PTR(opline->extended_value & ~ZEND_ISEMPTY, ce);
-                       }
-               }
-       } else {
-               if (IS_UNUSED == IS_UNUSED) {
-                       ce = zend_fetch_class(NULL, opline->op2.num);
-                       if (UNEXPECTED(ce == NULL)) {
-                               ZEND_ASSERT(EG(exception));
-
-                               ZVAL_UNDEF(EX_VAR(opline->result.var));
-                               HANDLE_EXCEPTION();
-                       }
-               } else {
-                       ce = Z_CE_P(EX_VAR(opline->op2.var));
-               }
-               if (IS_CONST == IS_CONST &&
-                   EXPECTED(CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY) == ce)) {
-
-                       value = CACHED_PTR((opline->extended_value & ~ZEND_ISEMPTY) + sizeof(void*));
-                       goto is_static_prop_return;
-               }
-       }
-
-       varname = RT_CONSTANT(opline, opline->op1);
-       if (IS_CONST == IS_CONST) {
-               name = Z_STR_P(varname);
-       } else {
-               name = zval_get_tmp_string(varname, &tmp_name);
-       }
-
-       value = zend_std_get_static_property(ce, name, 1);
 
-       if (IS_CONST == IS_CONST && value) {
-               CACHE_POLYMORPHIC_PTR(opline->extended_value & ~ZEND_ISEMPTY, ce, value);
-       }
+       result = zend_fetch_static_property_address(&value, NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0 OPLINE_CC EXECUTE_DATA_CC);
 
-       if (IS_CONST != IS_CONST) {
-               zend_tmp_string_release(tmp_name);
-       }
-
-is_static_prop_return:
        if (!(opline->extended_value & ZEND_ISEMPTY)) {
-               result = value && Z_TYPE_P(value) > IS_NULL &&
+               result = result == SUCCESS && Z_TYPE_P(value) > IS_NULL &&
                    (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
        } else {
-               result = !value || !i_zend_is_true(value);
+               result = result != SUCCESS || !i_zend_is_true(value);
        }
 
        ZEND_VM_SMART_BRANCH(result, 1);
@@ -9963,7 +11032,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_
                zval *retval;
 
                if (IS_CV == IS_CONST) {
-                       cache_slot = CACHE_ADDR(opline->extended_value);
+                       cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
                                uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
@@ -10116,7 +11185,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_AR
                if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
                        ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
                }
-
                ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
                ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -13505,95 +14573,83 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HAN
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_TMPVAR_CONST(int type ZEND_OPCODE_HANDLER_ARGS_DC)
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_static_property_helper_SPEC_TMPVAR_CONST(int inc ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
-       zend_free_op free_op1;
-       zval *varname;
-       zval *retval;
-       zend_string *name, *tmp_name;
-       zend_class_entry *ce;
+       zval *prop;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
 
-       do {
-               if (IS_CONST == IS_CONST) {
-                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value)) != NULL)) {
-                               retval = CACHED_PTR(opline->extended_value + sizeof(void*));
-                               break;
-                       } else {
-                               zval *class_name = RT_CONSTANT(opline, opline->op2);
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
 
-                               if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value)) == NULL)) {
-                                       ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
-                                       if (UNEXPECTED(ce == NULL)) {
-                                               zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
-                                               retval = NULL;
-                                               break;
-                                       }
-                                       if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
-                                               CACHE_PTR(opline->extended_value, ce);
-                                       }
-                               }
-                       }
-               } else {
-                       if (IS_CONST == IS_UNUSED) {
-                               ce = zend_fetch_class(NULL, opline->op2.num);
-                               if (UNEXPECTED(ce == NULL)) {
-                                       zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
-                                       retval = NULL;
-                                       break;
-                               }
-                       } else {
-                               ce = Z_CE_P(EX_VAR(opline->op2.var));
-                       }
-                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
-                           EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
-                               retval = CACHED_PTR(opline->extended_value + sizeof(void*));
-                               break;
-                       }
-               }
+       zend_pre_incdec_property_zval(prop, prop_info->type ? prop_info : NULL, inc OPLINE_CC EXECUTE_DATA_CC);
 
-               varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
-               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-                       name = Z_STR_P(varname);
-               } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
-                       name = Z_STR_P(varname);
-                       tmp_name = NULL;
-               } else {
-                       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
-                               zval_undefined_cv(EX(opline)->op1.var EXECUTE_DATA_CC);
-                       }
-                       name = zval_get_tmp_string(varname, &tmp_name);
-               }
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
 
-               retval = zend_std_get_static_property(ce, name, type == BP_VAR_IS);
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_pre_incdec_static_property_helper_SPEC_TMPVAR_CONST(1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
 
-               if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
-                       zend_tmp_string_release(tmp_name);
-               }
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_pre_incdec_static_property_helper_SPEC_TMPVAR_CONST(0 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
 
-               if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(retval)) {
-                       CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, retval);
-               }
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_static_property_helper_SPEC_TMPVAR_CONST(int inc ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       USE_OPLINE
+       zval *prop;
+       zend_property_info *prop_info;
 
-               zval_ptr_dtor_nogc(free_op1);
-       } while (0);
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       zend_post_incdec_property_zval(prop, prop_info->type ? prop_info : NULL, inc OPLINE_CC EXECUTE_DATA_CC);
+
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_post_incdec_static_property_helper_SPEC_TMPVAR_CONST(1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_post_incdec_static_property_helper_SPEC_TMPVAR_CONST(0 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_TMPVAR_CONST(int type ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       USE_OPLINE
+       zval *prop;
+
+       SAVE_OPLINE();
 
-       if (UNEXPECTED(retval == NULL)) {
+       if (UNEXPECTED(zend_fetch_static_property_address(&prop, NULL, opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS, type, opline->extended_value & ZEND_FETCH_OBJ_FLAGS OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
                if (EG(exception)) {
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                } else {
                        ZEND_ASSERT(type == BP_VAR_IS);
-                       retval = &EG(uninitialized_zval);
+                       prop = &EG(uninitialized_zval);
                }
        }
 
        if (type == BP_VAR_R || type == BP_VAR_IS) {
-               ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
+               ZVAL_COPY_DEREF(EX_VAR(opline->result.var), prop);
        } else {
-               ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
+               ZVAL_INDIRECT(EX_VAR(opline->result.var), prop);
        }
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -13726,7 +14782,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_
                zval *retval;
 
                if (IS_CONST == IS_CONST) {
-                       cache_slot = CACHE_ADDR(opline->extended_value);
+                       cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
                                uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
@@ -13872,6 +14928,282 @@ fetch_obj_is_finish:
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_CONST & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_CONST & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_CONST & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_CONST, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_TMP_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_TMP_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_TMP_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_VAR, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_CV & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_CV & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_CV & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_CV, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value_ptr;
+       zend_property_info *prop_info;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value & ~ZEND_RETURNS_FUNCTION, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value_ptr = get_zval_ptr_ptr((opline+1)->op1_type, (opline+1)->op1, &free_op_data, BP_VAR_W);
+
+       if ((opline+1)->op1_type == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               prop = &EG(uninitialized_zval);
+       } else if ((opline+1)->op1_type == IS_VAR && (opline->extended_value & ZEND_RETURNS_FUNCTION) && UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(prop, value_ptr, IS_CONST OPLINE_CC EXECUTE_DATA_CC))) {
+                       if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               if (UNEXPECTED(prop_info->type)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+                               if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+                               HANDLE_EXCEPTION();
+                       }
+                       if (UNEXPECTED(Z_REFCOUNTED_P(prop)) && Z_ISREF_P(prop)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(prop), prop_info);
+                       }
+               }
+       }
+       zend_assign_to_variable_reference(prop, value_ptr);
+       if (prop_info->type) {
+               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(prop), prop_info);
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+       }
+
+       if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -14238,71 +15570,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC
        USE_OPLINE
        zval *value;
        int result;
-       zend_free_op free_op1;
-       zval *varname;
-       zend_string *name, *tmp_name;
-       zend_class_entry *ce;
 
        SAVE_OPLINE();
-       if (IS_CONST == IS_CONST) {
-               if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY)) != NULL)) {
-                       value = CACHED_PTR((opline->extended_value & ~ZEND_ISEMPTY) + sizeof(void*));
-                       goto is_static_prop_return;
-               } else if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY)) == NULL)) {
-                       ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
-                       if (UNEXPECTED(ce == NULL)) {
-                               ZEND_ASSERT(EG(exception));
-                               ZVAL_UNDEF(EX_VAR(opline->result.var));
-                               HANDLE_EXCEPTION();
-                       }
-                       if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
-                               CACHE_PTR(opline->extended_value & ~ZEND_ISEMPTY, ce);
-                       }
-               }
-       } else {
-               if (IS_CONST == IS_UNUSED) {
-                       ce = zend_fetch_class(NULL, opline->op2.num);
-                       if (UNEXPECTED(ce == NULL)) {
-                               ZEND_ASSERT(EG(exception));
-                               zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
-                               ZVAL_UNDEF(EX_VAR(opline->result.var));
-                               HANDLE_EXCEPTION();
-                       }
-               } else {
-                       ce = Z_CE_P(EX_VAR(opline->op2.var));
-               }
-               if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
-                   EXPECTED(CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY) == ce)) {
-
-                       value = CACHED_PTR((opline->extended_value & ~ZEND_ISEMPTY) + sizeof(void*));
-                       goto is_static_prop_return;
-               }
-       }
-
-       varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
-       if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-               name = Z_STR_P(varname);
-       } else {
-               name = zval_get_tmp_string(varname, &tmp_name);
-       }
-
-       value = zend_std_get_static_property(ce, name, 1);
 
-       if ((IS_TMP_VAR|IS_VAR) == IS_CONST && value) {
-               CACHE_POLYMORPHIC_PTR(opline->extended_value & ~ZEND_ISEMPTY, ce, value);
-       }
+       result = zend_fetch_static_property_address(&value, NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0 OPLINE_CC EXECUTE_DATA_CC);
 
-       if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
-               zend_tmp_string_release(tmp_name);
-       }
-       zval_ptr_dtor_nogc(free_op1);
-
-is_static_prop_return:
        if (!(opline->extended_value & ZEND_ISEMPTY)) {
-               result = value && Z_TYPE_P(value) > IS_NULL &&
+               result = result == SUCCESS && Z_TYPE_P(value) > IS_NULL &&
                    (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
        } else {
-               result = !value || !i_zend_is_true(value);
+               result = result != SUCCESS || !i_zend_is_true(value);
        }
 
        ZEND_VM_SMART_BRANCH(result, 1);
@@ -15352,7 +16629,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR
                zval *retval;
 
                if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-                       cache_slot = CACHE_ADDR(opline->extended_value);
+                       cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
                                uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
@@ -15955,95 +17232,83 @@ array_key_exists_array:
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_TMPVAR_VAR(int type ZEND_OPCODE_HANDLER_ARGS_DC)
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_static_property_helper_SPEC_TMPVAR_VAR(int inc ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
-       zend_free_op free_op1;
-       zval *varname;
-       zval *retval;
-       zend_string *name, *tmp_name;
-       zend_class_entry *ce;
+       zval *prop;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
 
-       do {
-               if (IS_VAR == IS_CONST) {
-                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value)) != NULL)) {
-                               retval = CACHED_PTR(opline->extended_value + sizeof(void*));
-                               break;
-                       } else {
-                               zval *class_name = RT_CONSTANT(opline, opline->op2);
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
 
-                               if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value)) == NULL)) {
-                                       ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
-                                       if (UNEXPECTED(ce == NULL)) {
-                                               zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
-                                               retval = NULL;
-                                               break;
-                                       }
-                                       if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
-                                               CACHE_PTR(opline->extended_value, ce);
-                                       }
-                               }
-                       }
-               } else {
-                       if (IS_VAR == IS_UNUSED) {
-                               ce = zend_fetch_class(NULL, opline->op2.num);
-                               if (UNEXPECTED(ce == NULL)) {
-                                       zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
-                                       retval = NULL;
-                                       break;
-                               }
-                       } else {
-                               ce = Z_CE_P(EX_VAR(opline->op2.var));
-                       }
-                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
-                           EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
-                               retval = CACHED_PTR(opline->extended_value + sizeof(void*));
-                               break;
-                       }
-               }
+       zend_pre_incdec_property_zval(prop, prop_info->type ? prop_info : NULL, inc OPLINE_CC EXECUTE_DATA_CC);
 
-               varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
-               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-                       name = Z_STR_P(varname);
-               } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
-                       name = Z_STR_P(varname);
-                       tmp_name = NULL;
-               } else {
-                       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
-                               zval_undefined_cv(EX(opline)->op1.var EXECUTE_DATA_CC);
-                       }
-                       name = zval_get_tmp_string(varname, &tmp_name);
-               }
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
 
-               retval = zend_std_get_static_property(ce, name, type == BP_VAR_IS);
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_pre_incdec_static_property_helper_SPEC_TMPVAR_VAR(1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
 
-               if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
-                       zend_tmp_string_release(tmp_name);
-               }
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_pre_incdec_static_property_helper_SPEC_TMPVAR_VAR(0 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
 
-               if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(retval)) {
-                       CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, retval);
-               }
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_static_property_helper_SPEC_TMPVAR_VAR(int inc ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       USE_OPLINE
+       zval *prop;
+       zend_property_info *prop_info;
 
-               zval_ptr_dtor_nogc(free_op1);
-       } while (0);
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       zend_post_incdec_property_zval(prop, prop_info->type ? prop_info : NULL, inc OPLINE_CC EXECUTE_DATA_CC);
+
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
 
-       if (UNEXPECTED(retval == NULL)) {
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_post_incdec_static_property_helper_SPEC_TMPVAR_VAR(1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_post_incdec_static_property_helper_SPEC_TMPVAR_VAR(0 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_TMPVAR_VAR(int type ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       USE_OPLINE
+       zval *prop;
+
+       SAVE_OPLINE();
+
+       if (UNEXPECTED(zend_fetch_static_property_address(&prop, NULL, opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS, type, opline->extended_value & ZEND_FETCH_OBJ_FLAGS OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
                if (EG(exception)) {
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                } else {
                        ZEND_ASSERT(type == BP_VAR_IS);
-                       retval = &EG(uninitialized_zval);
+                       prop = &EG(uninitialized_zval);
                }
        }
 
        if (type == BP_VAR_R || type == BP_VAR_IS) {
-               ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
+               ZVAL_COPY_DEREF(EX_VAR(opline->result.var), prop);
        } else {
-               ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
+               ZVAL_INDIRECT(EX_VAR(opline->result.var), prop);
        }
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -16081,6 +17346,282 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPV
        ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC_TMPVAR_VAR(BP_VAR_IS ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_CONST & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_CONST & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_CONST & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_CONST, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_TMP_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_TMP_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_TMP_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_VAR, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_CV & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_CV & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_CV & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_CV, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value_ptr;
+       zend_property_info *prop_info;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value & ~ZEND_RETURNS_FUNCTION, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value_ptr = get_zval_ptr_ptr((opline+1)->op1_type, (opline+1)->op1, &free_op_data, BP_VAR_W);
+
+       if ((opline+1)->op1_type == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               prop = &EG(uninitialized_zval);
+       } else if ((opline+1)->op1_type == IS_VAR && (opline->extended_value & ZEND_RETURNS_FUNCTION) && UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(prop, value_ptr, IS_VAR OPLINE_CC EXECUTE_DATA_CC))) {
+                       if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               if (UNEXPECTED(prop_info->type)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+                               if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+                               HANDLE_EXCEPTION();
+                       }
+                       if (UNEXPECTED(Z_REFCOUNTED_P(prop)) && Z_ISREF_P(prop)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(prop), prop_info);
+                       }
+               }
+       }
+       zend_assign_to_variable_reference(prop, value_ptr);
+       if (prop_info->type) {
+               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(prop), prop_info);
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+       }
+
+       if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -16140,71 +17681,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC
        USE_OPLINE
        zval *value;
        int result;
-       zend_free_op free_op1;
-       zval *varname;
-       zend_string *name, *tmp_name;
-       zend_class_entry *ce;
 
        SAVE_OPLINE();
-       if (IS_VAR == IS_CONST) {
-               if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY)) != NULL)) {
-                       value = CACHED_PTR((opline->extended_value & ~ZEND_ISEMPTY) + sizeof(void*));
-                       goto is_static_prop_return;
-               } else if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY)) == NULL)) {
-                       ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
-                       if (UNEXPECTED(ce == NULL)) {
-                               ZEND_ASSERT(EG(exception));
-                               ZVAL_UNDEF(EX_VAR(opline->result.var));
-                               HANDLE_EXCEPTION();
-                       }
-                       if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
-                               CACHE_PTR(opline->extended_value & ~ZEND_ISEMPTY, ce);
-                       }
-               }
-       } else {
-               if (IS_VAR == IS_UNUSED) {
-                       ce = zend_fetch_class(NULL, opline->op2.num);
-                       if (UNEXPECTED(ce == NULL)) {
-                               ZEND_ASSERT(EG(exception));
-                               zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
-                               ZVAL_UNDEF(EX_VAR(opline->result.var));
-                               HANDLE_EXCEPTION();
-                       }
-               } else {
-                       ce = Z_CE_P(EX_VAR(opline->op2.var));
-               }
-               if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
-                   EXPECTED(CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY) == ce)) {
 
-                       value = CACHED_PTR((opline->extended_value & ~ZEND_ISEMPTY) + sizeof(void*));
-                       goto is_static_prop_return;
-               }
-       }
-
-       varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
-       if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-               name = Z_STR_P(varname);
-       } else {
-               name = zval_get_tmp_string(varname, &tmp_name);
-       }
-
-       value = zend_std_get_static_property(ce, name, 1);
-
-       if ((IS_TMP_VAR|IS_VAR) == IS_CONST && value) {
-               CACHE_POLYMORPHIC_PTR(opline->extended_value & ~ZEND_ISEMPTY, ce, value);
-       }
-
-       if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
-               zend_tmp_string_release(tmp_name);
-       }
-       zval_ptr_dtor_nogc(free_op1);
+       result = zend_fetch_static_property_address(&value, NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0 OPLINE_CC EXECUTE_DATA_CC);
 
-is_static_prop_return:
        if (!(opline->extended_value & ZEND_ISEMPTY)) {
-               result = value && Z_TYPE_P(value) > IS_NULL &&
+               result = result == SUCCESS && Z_TYPE_P(value) > IS_NULL &&
                    (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
        } else {
-               result = !value || !i_zend_is_true(value);
+               result = result != SUCCESS || !i_zend_is_true(value);
        }
 
        ZEND_VM_SMART_BRANCH(result, 1);
@@ -16261,6 +17747,62 @@ try_instanceof:
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_static_property_helper_SPEC_TMPVAR_UNUSED(int inc ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       USE_OPLINE
+       zval *prop;
+       zend_property_info *prop_info;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       zend_pre_incdec_property_zval(prop, prop_info->type ? prop_info : NULL, inc OPLINE_CC EXECUTE_DATA_CC);
+
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_pre_incdec_static_property_helper_SPEC_TMPVAR_UNUSED(1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_pre_incdec_static_property_helper_SPEC_TMPVAR_UNUSED(0 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_static_property_helper_SPEC_TMPVAR_UNUSED(int inc ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       USE_OPLINE
+       zval *prop;
+       zend_property_info *prop_info;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       zend_post_incdec_property_zval(prop, prop_info->type ? prop_info : NULL, inc OPLINE_CC EXECUTE_DATA_CC);
+
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_post_incdec_static_property_helper_SPEC_TMPVAR_UNUSED(1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_post_incdec_static_property_helper_SPEC_TMPVAR_UNUSED(0 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
@@ -16383,92 +17925,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HA
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_TMPVAR_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
-       zend_free_op free_op1;
-       zval *varname;
-       zval *retval;
-       zend_string *name, *tmp_name;
-       zend_class_entry *ce;
+       zval *prop;
 
        SAVE_OPLINE();
 
-       do {
-               if (IS_UNUSED == IS_CONST) {
-                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value)) != NULL)) {
-                               retval = CACHED_PTR(opline->extended_value + sizeof(void*));
-                               break;
-                       } else {
-                               zval *class_name = RT_CONSTANT(opline, opline->op2);
-
-                               if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value)) == NULL)) {
-                                       ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
-                                       if (UNEXPECTED(ce == NULL)) {
-                                               zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
-                                               retval = NULL;
-                                               break;
-                                       }
-                                       if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
-                                               CACHE_PTR(opline->extended_value, ce);
-                                       }
-                               }
-                       }
-               } else {
-                       if (IS_UNUSED == IS_UNUSED) {
-                               ce = zend_fetch_class(NULL, opline->op2.num);
-                               if (UNEXPECTED(ce == NULL)) {
-                                       zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
-                                       retval = NULL;
-                                       break;
-                               }
-                       } else {
-                               ce = Z_CE_P(EX_VAR(opline->op2.var));
-                       }
-                       if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
-                           EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
-                               retval = CACHED_PTR(opline->extended_value + sizeof(void*));
-                               break;
-                       }
-               }
-
-               varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
-               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-                       name = Z_STR_P(varname);
-               } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
-                       name = Z_STR_P(varname);
-                       tmp_name = NULL;
-               } else {
-                       if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
-                               zval_undefined_cv(EX(opline)->op1.var EXECUTE_DATA_CC);
-                       }
-                       name = zval_get_tmp_string(varname, &tmp_name);
-               }
-
-               retval = zend_std_get_static_property(ce, name, type == BP_VAR_IS);
-
-               if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
-                       zend_tmp_string_release(tmp_name);
-               }
-
-               if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(retval)) {
-                       CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, retval);
-               }
-
-               zval_ptr_dtor_nogc(free_op1);
-       } while (0);
-
-       if (UNEXPECTED(retval == NULL)) {
+       if (UNEXPECTED(zend_fetch_static_property_address(&prop, NULL, opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS, type, opline->extended_value & ZEND_FETCH_OBJ_FLAGS OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
                if (EG(exception)) {
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                } else {
                        ZEND_ASSERT(type == BP_VAR_IS);
-                       retval = &EG(uninitialized_zval);
+                       prop = &EG(uninitialized_zval);
                }
        }
 
        if (type == BP_VAR_R || type == BP_VAR_IS) {
-               ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
+               ZVAL_COPY_DEREF(EX_VAR(opline->result.var), prop);
        } else {
-               ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
+               ZVAL_INDIRECT(EX_VAR(opline->result.var), prop);
        }
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -16506,6 +17980,282 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPV
        ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC_TMPVAR_UNUSED(BP_VAR_IS ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_CONST & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_CONST & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_CONST & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_CONST, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_TMP_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_TMP_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_TMP_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_VAR, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_CV & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_CV & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_CV & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_CV, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value_ptr;
+       zend_property_info *prop_info;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value & ~ZEND_RETURNS_FUNCTION, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value_ptr = get_zval_ptr_ptr((opline+1)->op1_type, (opline+1)->op1, &free_op_data, BP_VAR_W);
+
+       if ((opline+1)->op1_type == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               prop = &EG(uninitialized_zval);
+       } else if ((opline+1)->op1_type == IS_VAR && (opline->extended_value & ZEND_RETURNS_FUNCTION) && UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(prop, value_ptr, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC))) {
+                       if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               if (UNEXPECTED(prop_info->type)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+                               if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+                               HANDLE_EXCEPTION();
+                       }
+                       if (UNEXPECTED(Z_REFCOUNTED_P(prop)) && Z_ISREF_P(prop)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(prop), prop_info);
+                       }
+               }
+       }
+       zend_assign_to_variable_reference(prop, value_ptr);
+       if (prop_info->type) {
+               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(prop), prop_info);
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+       }
+
+       if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -16646,71 +18396,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC
        USE_OPLINE
        zval *value;
        int result;
-       zend_free_op free_op1;
-       zval *varname;
-       zend_string *name, *tmp_name;
-       zend_class_entry *ce;
 
        SAVE_OPLINE();
-       if (IS_UNUSED == IS_CONST) {
-               if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY)) != NULL)) {
-                       value = CACHED_PTR((opline->extended_value & ~ZEND_ISEMPTY) + sizeof(void*));
-                       goto is_static_prop_return;
-               } else if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY)) == NULL)) {
-                       ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
-                       if (UNEXPECTED(ce == NULL)) {
-                               ZEND_ASSERT(EG(exception));
-                               ZVAL_UNDEF(EX_VAR(opline->result.var));
-                               HANDLE_EXCEPTION();
-                       }
-                       if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
-                               CACHE_PTR(opline->extended_value & ~ZEND_ISEMPTY, ce);
-                       }
-               }
-       } else {
-               if (IS_UNUSED == IS_UNUSED) {
-                       ce = zend_fetch_class(NULL, opline->op2.num);
-                       if (UNEXPECTED(ce == NULL)) {
-                               ZEND_ASSERT(EG(exception));
-                               zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
-                               ZVAL_UNDEF(EX_VAR(opline->result.var));
-                               HANDLE_EXCEPTION();
-                       }
-               } else {
-                       ce = Z_CE_P(EX_VAR(opline->op2.var));
-               }
-               if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
-                   EXPECTED(CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY) == ce)) {
 
-                       value = CACHED_PTR((opline->extended_value & ~ZEND_ISEMPTY) + sizeof(void*));
-                       goto is_static_prop_return;
-               }
-       }
-
-       varname = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
-       if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-               name = Z_STR_P(varname);
-       } else {
-               name = zval_get_tmp_string(varname, &tmp_name);
-       }
-
-       value = zend_std_get_static_property(ce, name, 1);
-
-       if ((IS_TMP_VAR|IS_VAR) == IS_CONST && value) {
-               CACHE_POLYMORPHIC_PTR(opline->extended_value & ~ZEND_ISEMPTY, ce, value);
-       }
-
-       if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
-               zend_tmp_string_release(tmp_name);
-       }
-       zval_ptr_dtor_nogc(free_op1);
+       result = zend_fetch_static_property_address(&value, NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0 OPLINE_CC EXECUTE_DATA_CC);
 
-is_static_prop_return:
        if (!(opline->extended_value & ZEND_ISEMPTY)) {
-               result = value && Z_TYPE_P(value) > IS_NULL &&
+               result = result == SUCCESS && Z_TYPE_P(value) > IS_NULL &&
                    (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
        } else {
-               result = !value || !i_zend_is_true(value);
+               result = result != SUCCESS || !i_zend_is_true(value);
        }
 
        ZEND_VM_SMART_BRANCH(result, 1);
@@ -17247,7 +18942,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HAN
                zval *retval;
 
                if (IS_CV == IS_CONST) {
-                       cache_slot = CACHE_ADDR(opline->extended_value);
+                       cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
                                uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
@@ -18617,6 +20312,152 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONS
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_static_prop_helper_SPEC_TMP_CONST(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       /* This helper actually never will receive IS_VAR as second op, and has the same handling for VAR and TMP in the first op, but for interoperability with the other binary_assign_op helpers, it is necessary to "include" it */
+
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zend_reference *ref;
+       zend_bool is_typed_ref = 0;
+
+       SAVE_OPLINE();
+
+       if (UNEXPECTED(zend_fetch_static_property_address(&prop, &prop_info, (opline+1)->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
+               ZEND_ASSERT(EG(exception));
+               UNDEF_RESULT();
+               FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
+               HANDLE_EXCEPTION();
+       }
+
+       value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data);
+
+       if (UNEXPECTED(Z_ISREF_P(prop))) {
+               ref = Z_REF_P(prop);
+               is_typed_ref = ZEND_REF_HAS_TYPE_SOURCES(ref);
+               prop = Z_REFVAL_P(prop);
+       }
+
+       if (UNEXPECTED(prop_info->type || is_typed_ref)) {
+               /* special case for typed properties */
+               zval z_copy;
+
+               binary_op(&z_copy, prop, value);
+               if (EXPECTED(is_typed_ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(prop);
+                       ZVAL_COPY_VALUE(prop, &z_copy);
+               } else {
+                       zval_ptr_dtor(&z_copy);
+               }
+       } else {
+               binary_op(prop, prop, value);
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+       }
+
+       FREE_OP(free_op_data);
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_TMP_CONST_STATIC_PROP(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+#if 1 && (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_TMP_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && (IS_CONST == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_TMP_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_TMP_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#else
+# if 0 || IS_TMP_VAR != IS_UNUSED
+#  if 0
+       /* opline->extended_value checks are specialized, don't need opline */
+       USE_OPLINE
+#  endif
+
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_simple_helper_SPEC_TMP_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_TMP_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  if 0 || IS_CONST == IS_CONST || IS_CONST == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(1)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_TMP_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
+# endif
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_TMP_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#endif
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_TMP_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_CONST_STATIC_PROP(add_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_TMP_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_CONST_STATIC_PROP(sub_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_TMP_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_CONST_STATIC_PROP(mul_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_TMP_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_CONST_STATIC_PROP(div_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_TMP_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_CONST_STATIC_PROP(mod_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_TMP_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_CONST_STATIC_PROP(shift_left_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_TMP_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_CONST_STATIC_PROP(shift_right_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_TMP_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_CONST_STATIC_PROP(concat_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_TMP_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_CONST_STATIC_PROP(bitwise_or_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_TMP_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_CONST_STATIC_PROP(bitwise_and_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_TMP_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_CONST_STATIC_PROP(bitwise_xor_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_TMP_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_CONST_STATIC_PROP(pow_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
@@ -18639,7 +20480,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CO
                if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
                        ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
                }
-
                ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
                ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -19031,6 +20871,152 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLE
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_static_prop_helper_SPEC_TMP_TMPVAR(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       /* This helper actually never will receive IS_VAR as second op, and has the same handling for VAR and TMP in the first op, but for interoperability with the other binary_assign_op helpers, it is necessary to "include" it */
+
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zend_reference *ref;
+       zend_bool is_typed_ref = 0;
+
+       SAVE_OPLINE();
+
+       if (UNEXPECTED(zend_fetch_static_property_address(&prop, &prop_info, (opline+1)->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
+               ZEND_ASSERT(EG(exception));
+               UNDEF_RESULT();
+               FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
+               HANDLE_EXCEPTION();
+       }
+
+       value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data);
+
+       if (UNEXPECTED(Z_ISREF_P(prop))) {
+               ref = Z_REF_P(prop);
+               is_typed_ref = ZEND_REF_HAS_TYPE_SOURCES(ref);
+               prop = Z_REFVAL_P(prop);
+       }
+
+       if (UNEXPECTED(prop_info->type || is_typed_ref)) {
+               /* special case for typed properties */
+               zval z_copy;
+
+               binary_op(&z_copy, prop, value);
+               if (EXPECTED(is_typed_ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(prop);
+                       ZVAL_COPY_VALUE(prop, &z_copy);
+               } else {
+                       zval_ptr_dtor(&z_copy);
+               }
+       } else {
+               binary_op(prop, prop, value);
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+       }
+
+       FREE_OP(free_op_data);
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_TMP_TMPVAR_STATIC_PROP(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+#if 1 && (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_TMP_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && ((IS_TMP_VAR|IS_VAR) == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_TMP_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_TMP_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#else
+# if 0 || IS_TMP_VAR != IS_UNUSED
+#  if 0
+       /* opline->extended_value checks are specialized, don't need opline */
+       USE_OPLINE
+#  endif
+
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_simple_helper_SPEC_TMP_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_TMP_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  if 0 || (IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(1)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_TMP_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
+# endif
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_TMP_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#endif
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_TMPVAR_STATIC_PROP(add_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_TMPVAR_STATIC_PROP(sub_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_TMPVAR_STATIC_PROP(mul_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_TMPVAR_STATIC_PROP(div_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_TMPVAR_STATIC_PROP(mod_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_TMPVAR_STATIC_PROP(shift_left_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_TMPVAR_STATIC_PROP(shift_right_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_TMPVAR_STATIC_PROP(concat_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_TMPVAR_STATIC_PROP(bitwise_or_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_TMPVAR_STATIC_PROP(bitwise_and_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_TMPVAR_STATIC_PROP(bitwise_xor_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_TMPVAR_STATIC_PROP(pow_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
@@ -19053,7 +21039,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TM
                if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
                        ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
                }
-
                ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
                ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -19578,6 +21563,152 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEN
        ZEND_VM_RETURN();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_static_prop_helper_SPEC_TMP_UNUSED(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       /* This helper actually never will receive IS_VAR as second op, and has the same handling for VAR and TMP in the first op, but for interoperability with the other binary_assign_op helpers, it is necessary to "include" it */
+
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zend_reference *ref;
+       zend_bool is_typed_ref = 0;
+
+       SAVE_OPLINE();
+
+       if (UNEXPECTED(zend_fetch_static_property_address(&prop, &prop_info, (opline+1)->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
+               ZEND_ASSERT(EG(exception));
+               UNDEF_RESULT();
+               FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
+               HANDLE_EXCEPTION();
+       }
+
+       value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data);
+
+       if (UNEXPECTED(Z_ISREF_P(prop))) {
+               ref = Z_REF_P(prop);
+               is_typed_ref = ZEND_REF_HAS_TYPE_SOURCES(ref);
+               prop = Z_REFVAL_P(prop);
+       }
+
+       if (UNEXPECTED(prop_info->type || is_typed_ref)) {
+               /* special case for typed properties */
+               zval z_copy;
+
+               binary_op(&z_copy, prop, value);
+               if (EXPECTED(is_typed_ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(prop);
+                       ZVAL_COPY_VALUE(prop, &z_copy);
+               } else {
+                       zval_ptr_dtor(&z_copy);
+               }
+       } else {
+               binary_op(prop, prop, value);
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+       }
+
+       FREE_OP(free_op_data);
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_TMP_UNUSED_STATIC_PROP(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+#if 1 && (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_TMP_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && (IS_UNUSED == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_TMP_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_TMP_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#else
+# if 0 || IS_TMP_VAR != IS_UNUSED
+#  if 0
+       /* opline->extended_value checks are specialized, don't need opline */
+       USE_OPLINE
+#  endif
+
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_simple_helper_SPEC_TMP_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_TMP_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  if 0 || IS_UNUSED == IS_CONST || IS_UNUSED == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(1)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_TMP_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
+# endif
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_TMP_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#endif
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_UNUSED_STATIC_PROP(add_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_UNUSED_STATIC_PROP(sub_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_UNUSED_STATIC_PROP(mul_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_UNUSED_STATIC_PROP(div_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_UNUSED_STATIC_PROP(mod_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_UNUSED_STATIC_PROP(shift_left_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_UNUSED_STATIC_PROP(shift_right_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_UNUSED_STATIC_PROP(concat_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_UNUSED_STATIC_PROP(bitwise_or_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_UNUSED_STATIC_PROP(bitwise_and_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_UNUSED_STATIC_PROP(bitwise_xor_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_TMP_UNUSED_STATIC_PROP(pow_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
@@ -20013,7 +22144,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV
                if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
                        ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
                }
-
                ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
                ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -20425,9 +22555,35 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED
                ZVAL_NULL(var_ptr);
                ZVAL_UNDEFINED_OP1();
        }
-       ZVAL_DEREF(var_ptr);
 
-       increment_function(var_ptr);
+       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+               zend_reference *ref = Z_REF_P(var_ptr);
+               var_ptr = Z_REFVAL_P(var_ptr);
+               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                       zval old;
+                       ZVAL_COPY(&old, var_ptr);
+
+                       increment_function(var_ptr);
+
+                       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_DOUBLE) && Z_TYPE(old) == IS_LONG) {
+                               zend_throw_incdec_ref_error(ref, 1);
+                               ZVAL_COPY_VALUE(var_ptr, &old);
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               HANDLE_EXCEPTION();
+                       } else if (UNEXPECTED(!zend_verify_ref_assignable_zval(ref, var_ptr, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(var_ptr);
+                               ZVAL_COPY_VALUE(var_ptr, &old);
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               HANDLE_EXCEPTION();
+                       } else {
+                               zval_ptr_dtor(&old);
+                       }
+               } else {
+                       increment_function(var_ptr);
+               }
+       } else {
+               increment_function(var_ptr);
+       }
 
        if (UNEXPECTED(0)) {
                ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -20465,9 +22621,35 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_H
                ZVAL_NULL(var_ptr);
                ZVAL_UNDEFINED_OP1();
        }
-       ZVAL_DEREF(var_ptr);
 
-       increment_function(var_ptr);
+       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+               zend_reference *ref = Z_REF_P(var_ptr);
+               var_ptr = Z_REFVAL_P(var_ptr);
+               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                       zval old;
+                       ZVAL_COPY(&old, var_ptr);
+
+                       increment_function(var_ptr);
+
+                       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_DOUBLE) && Z_TYPE(old) == IS_LONG) {
+                               zend_throw_incdec_ref_error(ref, 1);
+                               ZVAL_COPY_VALUE(var_ptr, &old);
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               HANDLE_EXCEPTION();
+                       } else if (UNEXPECTED(!zend_verify_ref_assignable_zval(ref, var_ptr, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(var_ptr);
+                               ZVAL_COPY_VALUE(var_ptr, &old);
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               HANDLE_EXCEPTION();
+                       } else {
+                               zval_ptr_dtor(&old);
+                       }
+               } else {
+                       increment_function(var_ptr);
+               }
+       } else {
+               increment_function(var_ptr);
+       }
 
        if (UNEXPECTED(1)) {
                ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -20505,9 +22687,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED
                ZVAL_NULL(var_ptr);
                ZVAL_UNDEFINED_OP1();
        }
-       ZVAL_DEREF(var_ptr);
 
-       decrement_function(var_ptr);
+       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+               zend_reference *ref = Z_REF_P(var_ptr);
+               var_ptr = Z_REFVAL_P(var_ptr);
+
+               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                       zval old;
+                       ZVAL_COPY(&old, var_ptr);
+
+                       decrement_function(var_ptr);
+
+                       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_DOUBLE) && Z_TYPE(old) == IS_LONG) {
+                               zend_throw_incdec_ref_error(ref, 0);
+                               ZVAL_COPY_VALUE(var_ptr, &old);
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               HANDLE_EXCEPTION();
+                       } else if (UNEXPECTED(!zend_verify_ref_assignable_zval(ref, var_ptr, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(var_ptr);
+                               ZVAL_COPY_VALUE(var_ptr, &old);
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               HANDLE_EXCEPTION();
+                       } else {
+                               zval_ptr_dtor(&old);
+                       }
+               } else {
+                       decrement_function(var_ptr);
+               }
+       } else {
+               decrement_function(var_ptr);
+       }
 
        if (UNEXPECTED(0)) {
                ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -20545,9 +22754,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED_H
                ZVAL_NULL(var_ptr);
                ZVAL_UNDEFINED_OP1();
        }
-       ZVAL_DEREF(var_ptr);
 
-       decrement_function(var_ptr);
+       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+               zend_reference *ref = Z_REF_P(var_ptr);
+               var_ptr = Z_REFVAL_P(var_ptr);
+
+               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                       zval old;
+                       ZVAL_COPY(&old, var_ptr);
+
+                       decrement_function(var_ptr);
+
+                       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_DOUBLE) && Z_TYPE(old) == IS_LONG) {
+                               zend_throw_incdec_ref_error(ref, 0);
+                               ZVAL_COPY_VALUE(var_ptr, &old);
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               HANDLE_EXCEPTION();
+                       } else if (UNEXPECTED(!zend_verify_ref_assignable_zval(ref, var_ptr, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(var_ptr);
+                               ZVAL_COPY_VALUE(var_ptr, &old);
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               HANDLE_EXCEPTION();
+                       } else {
+                               zval_ptr_dtor(&old);
+                       }
+               } else {
+                       decrement_function(var_ptr);
+               }
+       } else {
+               decrement_function(var_ptr);
+       }
 
        if (UNEXPECTED(1)) {
                ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -20581,10 +22817,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND
                ZVAL_NULL(var_ptr);
                ZVAL_UNDEFINED_OP1();
        }
-       ZVAL_DEREF(var_ptr);
-       ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 
-       increment_function(var_ptr);
+       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+               zend_reference *ref = Z_REF_P(var_ptr);
+               var_ptr = Z_REFVAL_P(var_ptr);
+
+               ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+
+               increment_function(var_ptr);
+
+               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_DOUBLE) && Z_TYPE_P(EX_VAR(opline->result.var)) == IS_LONG) {
+                               zend_throw_incdec_ref_error(ref, 1);
+                               ZVAL_COPY_VALUE(var_ptr, EX_VAR(opline->result.var));
+                       } else if (UNEXPECTED(!zend_verify_ref_assignable_zval(ref, var_ptr, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(var_ptr);
+                               ZVAL_COPY_VALUE(var_ptr, EX_VAR(opline->result.var));
+                       }
+               }
+       } else {
+               ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+
+               increment_function(var_ptr);
+       }
 
        if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
@@ -20614,10 +22869,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND
                ZVAL_NULL(var_ptr);
                ZVAL_UNDEFINED_OP1();
        }
-       ZVAL_DEREF(var_ptr);
-       ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 
-       decrement_function(var_ptr);
+       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+               zend_reference *ref = Z_REF_P(var_ptr);
+               var_ptr = Z_REFVAL_P(var_ptr);
+
+               ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+
+               decrement_function(var_ptr);
+
+               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_DOUBLE) && Z_TYPE_P(EX_VAR(opline->result.var)) == IS_LONG) {
+                               zend_throw_incdec_ref_error(ref, 0);
+                               ZVAL_COPY_VALUE(var_ptr, EX_VAR(opline->result.var));
+                       } else if (UNEXPECTED(!zend_verify_ref_assignable_zval(ref, var_ptr, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(var_ptr);
+                               ZVAL_COPY_VALUE(var_ptr, EX_VAR(opline->result.var));
+                       }
+               }
+       } else {
+               ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+
+               decrement_function(var_ptr);
+       }
 
        if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
@@ -21534,7 +23808,7 @@ fe_fetch_r_exit:
 
        if (EXPECTED(opline->op2_type == IS_CV)) {
                zval *variable_ptr = EX_VAR(opline->op2.var);
-               zend_assign_to_variable(variable_ptr, value, IS_CV);
+               zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
        } else {
                zval *res = EX_VAR(opline->op2.var);
                zend_refcounted *gc = Z_COUNTED_P(value);
@@ -21617,6 +23891,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(Z
                                                value_type = Z_TYPE_INFO_P(value);
                                                if (EXPECTED(value_type != IS_UNDEF)
                                                 && EXPECTED(zend_check_property_access(Z_OBJ_P(array), p->key, 0) == SUCCESS)) {
+                                                       if ((value_type & Z_TYPE_MASK) != IS_REFERENCE) {
+                                                               zend_property_info *prop_info =
+                                                                       zend_get_typed_property_info_for_slot(Z_OBJ_P(array), value);
+                                                               if (UNEXPECTED(prop_info)) {
+                                                                       ZVAL_NEW_REF(value, value);
+                                                                       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(value), prop_info);
+                                                                       value_type = IS_REFERENCE_EX;
+                                                               }
+                                                       }
                                                        break;
                                                }
                                        } else if (EXPECTED(Z_OBJCE_P(array)->default_properties_count == 0)
@@ -21993,11 +24276,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONS
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
-       zend_free_op free_op1, free_op_data1;
+       zend_free_op free_op1, free_op_data;
        zval *object;
        zval *property;
        zval *value;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
@@ -22009,47 +24294,126 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        property = RT_CONSTANT(opline, opline->op2);
 
        do {
-               value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
+               value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data);
 
                if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto assign_op_object;
-                               }
+                               goto assign_op_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 assign_op_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        } else {
-                               ZVAL_DEREF(zptr);
+                               zval *orig_zptr = zptr;
+                               zend_reference *ref;
+                               zend_bool is_typed_ref = 0;
+
+                               if (UNEXPECTED(Z_ISREF_P(zptr))) {
+                                       ref = Z_REF_P(zptr);
+                                       is_typed_ref = ZEND_REF_HAS_TYPE_SOURCES(ref);
+                                       zptr = Z_REFVAL_P(zptr);
+                               }
+
+                               if (IS_CONST == IS_CONST) {
+                                       prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
+                               } else {
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
+                               }
+                               if (UNEXPECTED(prop_info || is_typed_ref)) {
+                                       /* special case for typed properties */
+                                       zval z_copy;
+
+                                       binary_op(&z_copy, zptr, value);
+                                       if (EXPECTED(is_typed_ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(zptr);
+                                               ZVAL_COPY_VALUE(zptr, &z_copy);
+                                       } else {
+                                               zval_ptr_dtor(&z_copy);
+                                       }
+                               } else {
+                                       binary_op(zptr, zptr, value);
+                               }
 
-                               binary_op(zptr, zptr, value);
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), zptr);
                                }
                        }
                } else {
-                       zend_assign_op_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL), value, binary_op OPLINE_CC EXECUTE_DATA_CC);
+                       zend_assign_op_overloaded_property(object, property, cache_slot, value, binary_op OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
-       FREE_OP(free_op_data1);
+       FREE_OP(free_op_data);
 
        if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
        /* assign_obj has two opcodes! */
        ZEND_VM_NEXT_OPCODE_EX(1, 2);
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_static_prop_helper_SPEC_VAR_CONST(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       /* This helper actually never will receive IS_VAR as second op, and has the same handling for VAR and TMP in the first op, but for interoperability with the other binary_assign_op helpers, it is necessary to "include" it */
+
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zend_reference *ref;
+       zend_bool is_typed_ref = 0;
+
+       SAVE_OPLINE();
+
+       if (UNEXPECTED(zend_fetch_static_property_address(&prop, &prop_info, (opline+1)->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
+               ZEND_ASSERT(EG(exception));
+               UNDEF_RESULT();
+               FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
+               HANDLE_EXCEPTION();
+       }
+
+       value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data);
+
+       if (UNEXPECTED(Z_ISREF_P(prop))) {
+               ref = Z_REF_P(prop);
+               is_typed_ref = ZEND_REF_HAS_TYPE_SOURCES(ref);
+               prop = Z_REFVAL_P(prop);
+       }
+
+       if (UNEXPECTED(prop_info->type || is_typed_ref)) {
+               /* special case for typed properties */
+               zval z_copy;
+
+               binary_op(&z_copy, prop, value);
+               if (EXPECTED(is_typed_ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(prop);
+                       ZVAL_COPY_VALUE(prop, &z_copy);
+               } else {
+                       zval_ptr_dtor(&z_copy);
+               }
+       } else {
+               binary_op(prop, prop, value);
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+       }
+
+       FREE_OP(free_op_data);
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
@@ -22080,12 +24444,32 @@ assign_dim_op_new_array:
                        if (UNEXPECTED(!var_ptr)) {
                                goto assign_dim_op_ret_null;
                        }
-                       ZVAL_DEREF(var_ptr);
                }
 
                value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
-               binary_op(var_ptr, var_ptr, value);
+               if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
+                       zend_reference *ref = Z_REF_P(var_ptr);
+                       var_ptr = Z_REFVAL_P(var_ptr);
+                       if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                               zval tmp;
+                               binary_op(&tmp, var_ptr, value);
+                               if (EXPECTED(zend_verify_ref_assignable_zval(ref, &tmp, EX_USES_STRICT_TYPES()))) {
+                                       zval_ptr_dtor(var_ptr);
+                                       ZVAL_COPY_VALUE(var_ptr, &tmp);
+                               } else {
+                                       zval_ptr_dtor(&tmp);
+
+                                       FREE_OP(free_op_data1);
+                                       if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                                       HANDLE_EXCEPTION();
+                               }
+                       } else {
+                               binary_op(var_ptr, var_ptr, value);
+                       }
+               } else {
+                       binary_op(var_ptr, var_ptr, value);
+               }
 
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -22156,9 +24540,25 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_simple_helper
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               ZVAL_DEREF(var_ptr);
+               zend_reference *ref = NULL;
+               if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+                       ref = Z_REF_P(var_ptr);
+                       var_ptr = Z_REFVAL_P(var_ptr);
+               }
 
-               binary_op(var_ptr, var_ptr, value);
+               if (UNEXPECTED(ref && ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                       zval tmp;
+                       binary_op(&tmp, var_ptr, value);
+
+                       if (UNEXPECTED(zend_verify_ref_assignable_zval(ref, &tmp, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(var_ptr);
+                               ZVAL_COPY_VALUE(var_ptr, &tmp);
+                       } else {
+                               zval_ptr_dtor(&tmp);
+                       }
+               } else {
+                       binary_op(var_ptr, var_ptr, value);
+               }
 
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -22171,8 +24571,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_simple_helper
 
 static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_VAR_CONST(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
-#if 1 && IS_CONST == IS_UNUSED
-       ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#if 1 && (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && (IS_CONST == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 #else
 # if 0 || IS_VAR != IS_UNUSED
 #  if 0
@@ -22186,6 +24592,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
        if (EXPECTED(0)) {
                ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
        }
+#  if 0 || IS_CONST == IS_CONST || IS_CONST == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
 # endif
 
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -22194,8 +24605,14 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
 
 static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_VAR_CONST_DIM(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
-#if 1 && IS_CONST == IS_UNUSED
-       ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#if 1 && (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && (IS_CONST == IS_UNUSED)
+       if (EXPECTED(1)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 #else
 # if 0 || IS_VAR != IS_UNUSED
 #  if 0
@@ -22209,6 +24626,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
        if (EXPECTED(1)) {
                ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
        }
+#  if 0 || IS_CONST == IS_CONST || IS_CONST == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
 # endif
 
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -22217,8 +24639,48 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
 
 static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_VAR_CONST_OBJ(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
-#if 1 && IS_CONST == IS_UNUSED
-       ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#if 1 && (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && (IS_CONST == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#else
+# if 0 || IS_VAR != IS_UNUSED
+#  if 0
+       /* opline->extended_value checks are specialized, don't need opline */
+       USE_OPLINE
+#  endif
+
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_simple_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  if 0 || IS_CONST == IS_CONST || IS_CONST == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
+# endif
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#endif
+}
+
+static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_VAR_CONST_STATIC_PROP(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+#if 1 && (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && (IS_CONST == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 #else
 # if 0 || IS_VAR != IS_UNUSED
 #  if 0
@@ -22232,6 +24694,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
        if (EXPECTED(0)) {
                ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
        }
+#  if 0 || IS_CONST == IS_CONST || IS_CONST == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(1)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
 # endif
 
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -22253,6 +24720,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_CONST_OBJ_
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST_OBJ(add_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST_STATIC_PROP(add_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST(sub_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -22268,6 +24740,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_CONST_OBJ_
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST_OBJ(sub_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST_STATIC_PROP(sub_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST(mul_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -22283,6 +24760,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_CONST_OBJ_
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST_OBJ(mul_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST_STATIC_PROP(mul_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST(div_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -22298,6 +24780,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_CONST_OBJ_
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST_OBJ(div_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST_STATIC_PROP(div_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST(mod_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -22313,6 +24800,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_CONST_OBJ_
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST_OBJ(mod_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST_STATIC_PROP(mod_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST(shift_left_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -22328,6 +24820,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_CONST_OBJ_H
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST_OBJ(shift_left_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST_STATIC_PROP(shift_left_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST(shift_right_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -22343,6 +24840,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_CONST_OBJ_H
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST_OBJ(shift_right_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST_STATIC_PROP(shift_right_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST(concat_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -22358,6 +24860,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_O
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST_OBJ(concat_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST_STATIC_PROP(concat_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_or_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -22373,6 +24880,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_OB
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST_OBJ(bitwise_or_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST_STATIC_PROP(bitwise_or_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_and_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -22388,6 +24900,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_O
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST_OBJ(bitwise_and_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST_STATIC_PROP(bitwise_and_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_xor_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -22403,6 +24920,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_O
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST_OBJ(bitwise_xor_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST_STATIC_PROP(bitwise_xor_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST(pow_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -22418,6 +24940,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_VAR_CONST_OBJ_
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST_OBJ(pow_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_VAR_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_CONST_STATIC_PROP(pow_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CONST(int inc ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
@@ -22425,6 +24952,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
        zval *object;
        zval *property;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
@@ -22437,46 +24966,34 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
 
        do {
                if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto pre_incdec_object;
-                               }
+                               goto pre_incdec_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 pre_incdec_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        } else {
-                               if (EXPECTED(Z_TYPE_P(zptr) == IS_LONG)) {
-                                       if (inc) {
-                                               fast_long_increment_function(zptr);
-                                       } else {
-                                               fast_long_decrement_function(zptr);
-                                       }
+                               if (IS_CONST == IS_CONST) {
+                                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
                                } else {
-                                       ZVAL_DEREF(zptr);
-
-                                       if (inc) {
-                                               increment_function(zptr);
-                                       } else {
-                                               decrement_function(zptr);
-                                       }
-                               }
-                               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                                       ZVAL_COPY(EX_VAR(opline->result.var), zptr);
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
                                }
+                               zend_pre_incdec_property_zval(zptr, prop_info, inc OPLINE_CC EXECUTE_DATA_CC);
                        }
                } else {
-                       zend_pre_incdec_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc OPLINE_CC EXECUTE_DATA_CC);
+                       zend_pre_incdec_overloaded_property(object, property, cache_slot, inc OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
@@ -22501,6 +25018,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
        zval *object;
        zval *property;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
@@ -22513,42 +25032,33 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
 
        do {
                if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto post_incdec_object;
-                               }
+                               goto post_incdec_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 post_incdec_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
                        } else {
-                               if (EXPECTED(Z_TYPE_P(zptr) == IS_LONG)) {
-                                       ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(zptr));
-                                       if (inc) {
-                                               fast_long_increment_function(zptr);
-                                       } else {
-                                               fast_long_decrement_function(zptr);
-                                       }
+                               if (IS_CONST == IS_CONST) {
+                                       prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
                                } else {
-                                       ZVAL_DEREF(zptr);
-                                       ZVAL_COPY(EX_VAR(opline->result.var), zptr);
-                                       if (inc) {
-                                               increment_function(zptr);
-                                       } else {
-                                               decrement_function(zptr);
-                                       }
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
                                }
+
+                               zend_post_incdec_property_zval(zptr, prop_info, inc OPLINE_CC EXECUTE_DATA_CC);
                        }
                } else {
-                       zend_post_incdec_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc OPLINE_CC EXECUTE_DATA_CC);
+                       zend_post_incdec_overloaded_property(object, property, cache_slot, inc OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
@@ -22647,7 +25157,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HAN
 
        property = RT_CONSTANT(opline, opline->op2);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_VAR, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_W OPLINE_CC);
+       zend_fetch_property_address(
+               result, container, IS_VAR, property, IS_CONST,
+               ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
+               BP_VAR_W, opline->extended_value & ZEND_FETCH_OBJ_FLAGS, 1 OPLINE_CC);
 
        if (IS_VAR == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -22669,7 +25182,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HA
        }
        property = RT_CONSTANT(opline, opline->op2);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_VAR, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW OPLINE_CC);
+       zend_fetch_property_address(result, container, IS_VAR, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, 1 OPLINE_CC);
 
        if (IS_VAR == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -22684,7 +25197,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CO
                if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
                        ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
                }
-
                ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
                ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -22706,7 +25218,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST
 
        property = RT_CONSTANT(opline, opline->op2);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_VAR, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET OPLINE_CC);
+       zend_fetch_property_address(result, container, IS_VAR, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, 1 OPLINE_CC);
 
        if (IS_VAR == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -22754,13 +25266,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
 
        if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
 
                        goto exit_assign_obj;
                }
@@ -22769,15 +25280,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D
 assign_object:
        if (IS_CONST == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_CONST & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_CONST & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+
+                                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_CONST == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_CONST & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_CONST);
+                                       value = zend_assign_to_variable(property_val, value, IS_CONST, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -22839,10 +25389,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
 
 exit_assign_obj:
@@ -22869,13 +25419,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D
        value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
                        zval_ptr_dtor_nogc(free_op_data);
                        goto exit_assign_obj;
                }
@@ -22884,15 +25433,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D
 assign_object:
        if (IS_CONST == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_TMP_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_TMP_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+
+                                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_TMP_VAR == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_TMP_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_TMP_VAR);
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -22954,10 +25542,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
        zval_ptr_dtor_nogc(free_op_data);
 exit_assign_obj:
@@ -22984,13 +25572,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D
        value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
                        zval_ptr_dtor_nogc(free_op_data);
                        goto exit_assign_obj;
                }
@@ -22999,15 +25586,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D
 assign_object:
        if (IS_CONST == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+
+                                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_VAR == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_VAR);
+                                       value = zend_assign_to_variable(property_val, value, IS_VAR, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -23069,10 +25695,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
        zval_ptr_dtor_nogc(free_op_data);
 exit_assign_obj:
@@ -23099,13 +25725,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D
        value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
        if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
 
                        goto exit_assign_obj;
                }
@@ -23114,15 +25739,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D
 assign_object:
        if (IS_CONST == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_CV & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_CV & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+
+                                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_CV == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_CV & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_CV);
+                                       value = zend_assign_to_variable(property_val, value, IS_CV, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -23184,10 +25848,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
 
 exit_assign_obj:
@@ -23201,14 +25865,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -23250,7 +25914,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = RT_CONSTANT((opline+1), (opline+1)->op1);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -23285,6 +25949,15 @@ try_assign_dim_array:
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+
+
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -23311,14 +25984,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -23360,7 +26033,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -23396,6 +26069,15 @@ try_assign_dim_array:
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+
+                               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -23422,14 +26104,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -23471,7 +26153,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -23507,6 +26189,15 @@ try_assign_dim_array:
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+
+                               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -23533,14 +26224,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_D
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -23582,7 +26273,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_CV);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -23617,6 +26308,15 @@ try_assign_dim_array:
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+
+
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -23656,7 +26356,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_U
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
+               value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
                if (UNEXPECTED(0)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -23684,7 +26384,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_U
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
+               value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
                if (UNEXPECTED(1)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -23695,6 +26395,194 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_U
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1, free_op_data;
+       zval *property;
+       zval *container;
+       zval variable, *variable_ptr = &variable;
+       zval *value_ptr;
+       void **cache_addr;
+
+       SAVE_OPLINE();
+
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+
+       if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
+               ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       }
+
+       property = RT_CONSTANT(opline, opline->op2);
+
+       cache_addr = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
+
+       zend_fetch_property_address(variable_ptr, container, IS_VAR, property, IS_CONST, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC);
+       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
+               variable_ptr = Z_INDIRECT_P(variable_ptr);
+       }
+
+       value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (UNEXPECTED(Z_TYPE(variable) != IS_INDIRECT)) {
+               zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
+               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+
+               if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (IS_VAR == IS_VAR &&
+                  opline->extended_value == ZEND_RETURNS_FUNCTION &&
+                          UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
+                               Z_INDIRECT_P(variable_ptr), value_ptr, IS_CONST OPLINE_CC EXECUTE_DATA_CC))) {
+                       if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+
+                       if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               zend_property_info *prop_info = NULL;
+
+               if (IS_CONST == IS_CONST) {
+                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
+               } else {
+                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
+               }
+
+               if (UNEXPECTED(prop_info)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+
+                               if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+                               HANDLE_EXCEPTION();
+                       }
+
+                       if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr)) && Z_ISREF_P(variable_ptr)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+                       }
+               }
+               zend_assign_to_variable_reference(variable_ptr, value_ptr);
+               if (prop_info) {
+                       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               }
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+       }
+
+       if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+
+       if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *property;
+       zval *container;
+       zval variable, *variable_ptr = &variable;
+       zval *value_ptr;
+       void **cache_addr;
+
+       SAVE_OPLINE();
+
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+
+       if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
+               ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       }
+
+       property = RT_CONSTANT(opline, opline->op2);
+
+       cache_addr = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
+
+       zend_fetch_property_address(variable_ptr, container, IS_VAR, property, IS_CONST, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC);
+       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
+               variable_ptr = Z_INDIRECT_P(variable_ptr);
+       }
+
+       value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (UNEXPECTED(Z_TYPE(variable) != IS_INDIRECT)) {
+               zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
+               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (IS_CV == IS_VAR &&
+                  opline->extended_value == ZEND_RETURNS_FUNCTION &&
+                          UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
+                               Z_INDIRECT_P(variable_ptr), value_ptr, IS_CONST OPLINE_CC EXECUTE_DATA_CC))) {
+                       if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+
+
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               zend_property_info *prop_info = NULL;
+
+               if (IS_CONST == IS_CONST) {
+                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
+               } else {
+                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
+               }
+
+               if (UNEXPECTED(prop_info)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+
+
+                               HANDLE_EXCEPTION();
+                       }
+
+                       if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr)) && Z_ISREF_P(variable_ptr)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+                       }
+               }
+               zend_assign_to_variable_reference(variable_ptr, value_ptr);
+               if (prop_info) {
+                       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               }
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+       }
+
+       if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+
+
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -24323,11 +27211,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLE
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
-       zend_free_op free_op1, free_op2, free_op_data1;
+       zend_free_op free_op1, free_op2, free_op_data;
        zval *object;
        zval *property;
        zval *value;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
@@ -24339,47 +27229,126 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        do {
-               value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
+               value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data);
 
                if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto assign_op_object;
-                               }
+                               goto assign_op_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 assign_op_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        } else {
-                               ZVAL_DEREF(zptr);
+                               zval *orig_zptr = zptr;
+                               zend_reference *ref;
+                               zend_bool is_typed_ref = 0;
+
+                               if (UNEXPECTED(Z_ISREF_P(zptr))) {
+                                       ref = Z_REF_P(zptr);
+                                       is_typed_ref = ZEND_REF_HAS_TYPE_SOURCES(ref);
+                                       zptr = Z_REFVAL_P(zptr);
+                               }
+
+                               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                                       prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
+                               } else {
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
+                               }
+                               if (UNEXPECTED(prop_info || is_typed_ref)) {
+                                       /* special case for typed properties */
+                                       zval z_copy;
+
+                                       binary_op(&z_copy, zptr, value);
+                                       if (EXPECTED(is_typed_ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(zptr);
+                                               ZVAL_COPY_VALUE(zptr, &z_copy);
+                                       } else {
+                                               zval_ptr_dtor(&z_copy);
+                                       }
+                               } else {
+                                       binary_op(zptr, zptr, value);
+                               }
 
-                               binary_op(zptr, zptr, value);
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), zptr);
                                }
                        }
                } else {
-                       zend_assign_op_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL), value, binary_op OPLINE_CC EXECUTE_DATA_CC);
+                       zend_assign_op_overloaded_property(object, property, cache_slot, value, binary_op OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
-       FREE_OP(free_op_data1);
+       FREE_OP(free_op_data);
        zval_ptr_dtor_nogc(free_op2);
        if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
        /* assign_obj has two opcodes! */
        ZEND_VM_NEXT_OPCODE_EX(1, 2);
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_static_prop_helper_SPEC_VAR_TMPVAR(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       /* This helper actually never will receive IS_VAR as second op, and has the same handling for VAR and TMP in the first op, but for interoperability with the other binary_assign_op helpers, it is necessary to "include" it */
+
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zend_reference *ref;
+       zend_bool is_typed_ref = 0;
+
+       SAVE_OPLINE();
+
+       if (UNEXPECTED(zend_fetch_static_property_address(&prop, &prop_info, (opline+1)->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
+               ZEND_ASSERT(EG(exception));
+               UNDEF_RESULT();
+               FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
+               HANDLE_EXCEPTION();
+       }
+
+       value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data);
+
+       if (UNEXPECTED(Z_ISREF_P(prop))) {
+               ref = Z_REF_P(prop);
+               is_typed_ref = ZEND_REF_HAS_TYPE_SOURCES(ref);
+               prop = Z_REFVAL_P(prop);
+       }
+
+       if (UNEXPECTED(prop_info->type || is_typed_ref)) {
+               /* special case for typed properties */
+               zval z_copy;
+
+               binary_op(&z_copy, prop, value);
+               if (EXPECTED(is_typed_ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(prop);
+                       ZVAL_COPY_VALUE(prop, &z_copy);
+               } else {
+                       zval_ptr_dtor(&z_copy);
+               }
+       } else {
+               binary_op(prop, prop, value);
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+       }
+
+       FREE_OP(free_op_data);
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
@@ -24410,12 +27379,32 @@ assign_dim_op_new_array:
                        if (UNEXPECTED(!var_ptr)) {
                                goto assign_dim_op_ret_null;
                        }
-                       ZVAL_DEREF(var_ptr);
                }
 
                value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
-               binary_op(var_ptr, var_ptr, value);
+               if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
+                       zend_reference *ref = Z_REF_P(var_ptr);
+                       var_ptr = Z_REFVAL_P(var_ptr);
+                       if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                               zval tmp;
+                               binary_op(&tmp, var_ptr, value);
+                               if (EXPECTED(zend_verify_ref_assignable_zval(ref, &tmp, EX_USES_STRICT_TYPES()))) {
+                                       zval_ptr_dtor(var_ptr);
+                                       ZVAL_COPY_VALUE(var_ptr, &tmp);
+                               } else {
+                                       zval_ptr_dtor(&tmp);
+                                       zval_ptr_dtor_nogc(free_op2);
+                                       FREE_OP(free_op_data1);
+                                       if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                                       HANDLE_EXCEPTION();
+                               }
+                       } else {
+                               binary_op(var_ptr, var_ptr, value);
+                       }
+               } else {
+                       binary_op(var_ptr, var_ptr, value);
+               }
 
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -24487,9 +27476,25 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_simple_helper
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               ZVAL_DEREF(var_ptr);
+               zend_reference *ref = NULL;
+               if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+                       ref = Z_REF_P(var_ptr);
+                       var_ptr = Z_REFVAL_P(var_ptr);
+               }
 
-               binary_op(var_ptr, var_ptr, value);
+               if (UNEXPECTED(ref && ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                       zval tmp;
+                       binary_op(&tmp, var_ptr, value);
+
+                       if (UNEXPECTED(zend_verify_ref_assignable_zval(ref, &tmp, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(var_ptr);
+                               ZVAL_COPY_VALUE(var_ptr, &tmp);
+                       } else {
+                               zval_ptr_dtor(&tmp);
+                       }
+               } else {
+                       binary_op(var_ptr, var_ptr, value);
+               }
 
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -24503,8 +27508,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_simple_helper
 
 static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
-#if 1 && (IS_TMP_VAR|IS_VAR) == IS_UNUSED
-       ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#if 1 && (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && ((IS_TMP_VAR|IS_VAR) == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 #else
 # if 0 || IS_VAR != IS_UNUSED
 #  if 0
@@ -24518,6 +27529,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
        if (EXPECTED(0)) {
                ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
        }
+#  if 0 || (IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
 # endif
 
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -24526,8 +27542,14 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
 
 static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_DIM(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
-#if 1 && (IS_TMP_VAR|IS_VAR) == IS_UNUSED
-       ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#if 1 && (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && ((IS_TMP_VAR|IS_VAR) == IS_UNUSED)
+       if (EXPECTED(1)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 #else
 # if 0 || IS_VAR != IS_UNUSED
 #  if 0
@@ -24541,6 +27563,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
        if (EXPECTED(1)) {
                ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
        }
+#  if 0 || (IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
 # endif
 
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -24549,8 +27576,48 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
 
 static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_OBJ(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
-#if 1 && (IS_TMP_VAR|IS_VAR) == IS_UNUSED
-       ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#if 1 && (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && ((IS_TMP_VAR|IS_VAR) == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#else
+# if 0 || IS_VAR != IS_UNUSED
+#  if 0
+       /* opline->extended_value checks are specialized, don't need opline */
+       USE_OPLINE
+#  endif
+
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_simple_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  if 0 || (IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
+# endif
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#endif
+}
+
+static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_STATIC_PROP(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+#if 1 && (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && ((IS_TMP_VAR|IS_VAR) == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 #else
 # if 0 || IS_VAR != IS_UNUSED
 #  if 0
@@ -24564,6 +27631,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
        if (EXPECTED(0)) {
                ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
        }
+#  if 0 || (IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(1)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
 # endif
 
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -24585,6 +27657,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_OBJ
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_OBJ(add_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_STATIC_PROP(add_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(sub_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -24600,6 +27677,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_OBJ
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_OBJ(sub_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_STATIC_PROP(sub_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(mul_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -24615,6 +27697,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_OBJ
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_OBJ(mul_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_STATIC_PROP(mul_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(div_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -24630,6 +27717,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_OBJ
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_OBJ(div_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_STATIC_PROP(div_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(mod_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -24645,6 +27737,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_OBJ
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_OBJ(mod_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_STATIC_PROP(mod_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(shift_left_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -24660,6 +27757,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_OBJ_
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_OBJ(shift_left_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_STATIC_PROP(shift_left_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(shift_right_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -24675,6 +27777,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_OBJ_
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_OBJ(shift_right_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_STATIC_PROP(shift_right_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(concat_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -24690,6 +27797,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_OBJ(concat_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_STATIC_PROP(concat_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(bitwise_or_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -24705,6 +27817,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_O
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_OBJ(bitwise_or_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_STATIC_PROP(bitwise_or_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(bitwise_and_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -24720,6 +27837,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_OBJ(bitwise_and_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_STATIC_PROP(bitwise_and_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(bitwise_xor_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -24735,6 +27857,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_OBJ(bitwise_xor_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_STATIC_PROP(bitwise_xor_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(pow_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -24750,6 +27877,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_OBJ(pow_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_TMPVAR_STATIC_PROP(pow_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_TMPVAR(int inc ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
@@ -24757,6 +27889,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
        zval *object;
        zval *property;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
@@ -24769,46 +27903,34 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
 
        do {
                if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto pre_incdec_object;
-                               }
+                               goto pre_incdec_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 pre_incdec_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        } else {
-                               if (EXPECTED(Z_TYPE_P(zptr) == IS_LONG)) {
-                                       if (inc) {
-                                               fast_long_increment_function(zptr);
-                                       } else {
-                                               fast_long_decrement_function(zptr);
-                                       }
+                               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
                                } else {
-                                       ZVAL_DEREF(zptr);
-
-                                       if (inc) {
-                                               increment_function(zptr);
-                                       } else {
-                                               decrement_function(zptr);
-                                       }
-                               }
-                               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                                       ZVAL_COPY(EX_VAR(opline->result.var), zptr);
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
                                }
+                               zend_pre_incdec_property_zval(zptr, prop_info, inc OPLINE_CC EXECUTE_DATA_CC);
                        }
                } else {
-                       zend_pre_incdec_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc OPLINE_CC EXECUTE_DATA_CC);
+                       zend_pre_incdec_overloaded_property(object, property, cache_slot, inc OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
@@ -24834,6 +27956,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
        zval *object;
        zval *property;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
@@ -24846,42 +27970,33 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
 
        do {
                if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto post_incdec_object;
-                               }
+                               goto post_incdec_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 post_incdec_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
                        } else {
-                               if (EXPECTED(Z_TYPE_P(zptr) == IS_LONG)) {
-                                       ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(zptr));
-                                       if (inc) {
-                                               fast_long_increment_function(zptr);
-                                       } else {
-                                               fast_long_decrement_function(zptr);
-                                       }
+                               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                                       prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
                                } else {
-                                       ZVAL_DEREF(zptr);
-                                       ZVAL_COPY(EX_VAR(opline->result.var), zptr);
-                                       if (inc) {
-                                               increment_function(zptr);
-                                       } else {
-                                               decrement_function(zptr);
-                                       }
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
                                }
+
+                               zend_post_incdec_property_zval(zptr, prop_info, inc OPLINE_CC EXECUTE_DATA_CC);
                        }
                } else {
-                       zend_post_incdec_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc OPLINE_CC EXECUTE_DATA_CC);
+                       zend_post_incdec_overloaded_property(object, property, cache_slot, inc OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
@@ -24981,7 +28096,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HA
 
        property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_W OPLINE_CC);
+       zend_fetch_property_address(
+               result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR),
+               (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
+               BP_VAR_W, opline->extended_value & ZEND_FETCH_OBJ_FLAGS, 1 OPLINE_CC);
        zval_ptr_dtor_nogc(free_op2);
        if (IS_VAR == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -25003,7 +28121,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_H
        }
        property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW OPLINE_CC);
+       zend_fetch_property_address(result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, 1 OPLINE_CC);
        zval_ptr_dtor_nogc(free_op2);
        if (IS_VAR == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -25018,7 +28136,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TM
                if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
                        ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
                }
-
                ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
                ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -25040,7 +28157,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVA
 
        property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET OPLINE_CC);
+       zend_fetch_property_address(result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, 1 OPLINE_CC);
        zval_ptr_dtor_nogc(free_op2);
        if (IS_VAR == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -25089,14 +28206,166 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
 
        if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
+                       goto assign_object;
+               }
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
+
+                       goto exit_assign_obj;
+               }
+       }
+
+assign_object:
+       if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
+           EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
+               zend_object *zobj = Z_OBJ_P(object);
+               zval *property_val;
+
+               if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
+                       property_val = OBJ_PROP(zobj, prop_offset);
+                       if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_CONST & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_CONST & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+                                               zval_ptr_dtor_nogc(free_op2);
+                                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_CONST == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_CONST & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
+fast_assign_obj:
+                                       value = zend_assign_to_variable(property_val, value, IS_CONST, EX_USES_STRICT_TYPES());
+                               }
+                               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+                                       ZVAL_COPY(EX_VAR(opline->result.var), value);
+                               }
+                               goto exit_assign_obj;
+                       }
+               } else {
+                       if (EXPECTED(zobj->properties != NULL)) {
+                               if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
+                                       if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
+                                               GC_DELREF(zobj->properties);
+                                       }
+                                       zobj->properties = zend_array_dup(zobj->properties);
+                               }
+                               property_val = zend_hash_find_ex(zobj->properties, Z_STR_P(property), 1);
+                               if (property_val) {
+                                       goto fast_assign_obj;
+                               }
+                       }
+
+                       if (!zobj->ce->__set) {
+
+                               if (EXPECTED(zobj->properties == NULL)) {
+                                       rebuild_object_properties(zobj);
+                               }
+                               if (IS_CONST == IS_CONST) {
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
+                                               Z_ADDREF_P(value);
+                                       }
+                               } else if (IS_CONST != IS_TMP_VAR) {
+                                       if (Z_ISREF_P(value)) {
+                                               if (IS_CONST == IS_VAR) {
+                                                       zend_reference *ref = Z_REF_P(value);
+                                                       if (GC_DELREF(ref) == 0) {
+                                                               ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
+                                                               efree_size(ref, sizeof(zend_reference));
+                                                               value = &tmp;
+                                                       } else {
+                                                               value = Z_REFVAL_P(value);
+                                                               Z_TRY_ADDREF_P(value);
+                                                       }
+                                               } else {
+                                                       value = Z_REFVAL_P(value);
+                                                       Z_TRY_ADDREF_P(value);
+                                               }
+                                       } else if (IS_CONST == IS_CV) {
+                                               Z_TRY_ADDREF_P(value);
+                                       }
+                               }
+                               zend_hash_add_new(zobj->properties, Z_STR_P(property), value);
+                               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+                                       ZVAL_COPY(EX_VAR(opline->result.var), value);
+                               }
+                               goto exit_assign_obj;
                        }
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+       }
 
+       if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
+               ZVAL_DEREF(value);
+       }
+
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
+       }
+
+exit_assign_obj:
+       zval_ptr_dtor_nogc(free_op2);
+       if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+       /* assign_obj has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1, free_op2, free_op_data;
+       zval *object, *property, *value, tmp;
+
+       SAVE_OPLINE();
+       object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+
+       if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
+               ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       }
+
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
+                       object = Z_REFVAL_P(object);
+                       goto assign_object;
+               }
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
+                       zval_ptr_dtor_nogc(free_op_data);
                        goto exit_assign_obj;
                }
        }
@@ -25104,130 +28373,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_
 assign_object:
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_TMP_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_TMP_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+                                               zval_ptr_dtor_nogc(free_op2);
+                                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_TMP_VAR == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_TMP_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_CONST);
-                               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-                               }
-                               goto exit_assign_obj;
-                       }
-               } else {
-                       if (EXPECTED(zobj->properties != NULL)) {
-                               if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
-                                       if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
-                                               GC_DELREF(zobj->properties);
-                                       }
-                                       zobj->properties = zend_array_dup(zobj->properties);
-                               }
-                               property_val = zend_hash_find_ex(zobj->properties, Z_STR_P(property), 1);
-                               if (property_val) {
-                                       goto fast_assign_obj;
-                               }
-                       }
-
-                       if (!zobj->ce->__set) {
-
-                               if (EXPECTED(zobj->properties == NULL)) {
-                                       rebuild_object_properties(zobj);
-                               }
-                               if (IS_CONST == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
-                                               Z_ADDREF_P(value);
-                                       }
-                               } else if (IS_CONST != IS_TMP_VAR) {
-                                       if (Z_ISREF_P(value)) {
-                                               if (IS_CONST == IS_VAR) {
-                                                       zend_reference *ref = Z_REF_P(value);
-                                                       if (GC_DELREF(ref) == 0) {
-                                                               ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
-                                                               efree_size(ref, sizeof(zend_reference));
-                                                               value = &tmp;
-                                                       } else {
-                                                               value = Z_REFVAL_P(value);
-                                                               Z_TRY_ADDREF_P(value);
-                                                       }
-                                               } else {
-                                                       value = Z_REFVAL_P(value);
-                                                       Z_TRY_ADDREF_P(value);
-                                               }
-                                       } else if (IS_CONST == IS_CV) {
-                                               Z_TRY_ADDREF_P(value);
-                                       }
-                               }
-                               zend_hash_add_new(zobj->properties, Z_STR_P(property), value);
-                               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-                               }
-                               goto exit_assign_obj;
-                       }
-               }
-       }
-
-       if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
-               ZVAL_DEREF(value);
-       }
-
-       Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
-
-       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
-       }
-
-exit_assign_obj:
-       zval_ptr_dtor_nogc(free_op2);
-       if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
-       /* assign_obj has two opcodes! */
-       ZEND_VM_NEXT_OPCODE_EX(1, 2);
-}
-
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1, free_op2, free_op_data;
-       zval *object, *property, *value, tmp;
-
-       SAVE_OPLINE();
-       object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
-
-       if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
-               ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
-       }
-
-       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
-       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-
-       if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
-                       object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
-               }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
-                       zval_ptr_dtor_nogc(free_op_data);
-                       goto exit_assign_obj;
-               }
-       }
-
-assign_object:
-       if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
-           EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
-               zend_object *zobj = Z_OBJ_P(object);
-               zval *property_val;
-
-               if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
-                       property_val = OBJ_PROP(zobj, prop_offset);
-                       if (Z_TYPE_P(property_val) != IS_UNDEF) {
-fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_TMP_VAR);
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -25289,10 +28482,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
        zval_ptr_dtor_nogc(free_op_data);
 exit_assign_obj:
@@ -25319,13 +28512,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_
        value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
                        zval_ptr_dtor_nogc(free_op_data);
                        goto exit_assign_obj;
                }
@@ -25334,15 +28526,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_
 assign_object:
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+                                               zval_ptr_dtor_nogc(free_op2);
+                                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_VAR == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_VAR);
+                                       value = zend_assign_to_variable(property_val, value, IS_VAR, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -25404,10 +28635,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
        zval_ptr_dtor_nogc(free_op_data);
 exit_assign_obj:
@@ -25434,13 +28665,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_
        value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
        if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
 
                        goto exit_assign_obj;
                }
@@ -25449,15 +28679,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_
 assign_object:
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_CV & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_CV & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+                                               zval_ptr_dtor_nogc(free_op2);
+                                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_CV == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_CV & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_CV);
+                                       value = zend_assign_to_variable(property_val, value, IS_CV, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -25519,10 +28788,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
 
 exit_assign_obj:
@@ -25536,14 +28805,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op2, free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -25585,7 +28854,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = RT_CONSTANT((opline+1), (opline+1)->op1);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -25620,6 +28889,15 @@ try_assign_dim_array:
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+                               zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
+
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -25646,14 +28924,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op2, free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -25695,7 +28973,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -25731,6 +29009,15 @@ try_assign_dim_array:
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+                               zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
+                               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -25757,14 +29044,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op2, free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -25806,7 +29093,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -25842,6 +29129,15 @@ try_assign_dim_array:
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+                               zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
+                               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -25868,14 +29164,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op2, free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -25917,7 +29213,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_CV);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -25952,6 +29248,15 @@ try_assign_dim_array:
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+                               zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
+
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -25974,6 +29279,194 @@ assign_dim_error:
        ZEND_VM_NEXT_OPCODE_EX(1, 2);
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1, free_op2, free_op_data;
+       zval *property;
+       zval *container;
+       zval variable, *variable_ptr = &variable;
+       zval *value_ptr;
+       void **cache_addr;
+
+       SAVE_OPLINE();
+
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+
+       if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
+               ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       }
+
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+
+       cache_addr = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
+
+       zend_fetch_property_address(variable_ptr, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), cache_addr, BP_VAR_W, 0, 0 OPLINE_CC);
+       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
+               variable_ptr = Z_INDIRECT_P(variable_ptr);
+       }
+
+       value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (UNEXPECTED(Z_TYPE(variable) != IS_INDIRECT)) {
+               zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
+               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+               zval_ptr_dtor_nogc(free_op2);
+               if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (IS_VAR == IS_VAR &&
+                  opline->extended_value == ZEND_RETURNS_FUNCTION &&
+                          UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
+                               Z_INDIRECT_P(variable_ptr), value_ptr, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC))) {
+                       if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                       zval_ptr_dtor_nogc(free_op2);
+                       if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+               zval_ptr_dtor_nogc(free_op2);
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               zend_property_info *prop_info = NULL;
+
+               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
+               } else {
+                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
+               }
+
+               if (UNEXPECTED(prop_info)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               zval_ptr_dtor_nogc(free_op2);
+                               if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+                               HANDLE_EXCEPTION();
+                       }
+
+                       if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr)) && Z_ISREF_P(variable_ptr)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+                       }
+               }
+               zend_assign_to_variable_reference(variable_ptr, value_ptr);
+               if (prop_info) {
+                       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               }
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+       }
+
+       if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+       zval_ptr_dtor_nogc(free_op2);
+       if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1, free_op2;
+       zval *property;
+       zval *container;
+       zval variable, *variable_ptr = &variable;
+       zval *value_ptr;
+       void **cache_addr;
+
+       SAVE_OPLINE();
+
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+
+       if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
+               ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       }
+
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+
+       cache_addr = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
+
+       zend_fetch_property_address(variable_ptr, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), cache_addr, BP_VAR_W, 0, 0 OPLINE_CC);
+       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
+               variable_ptr = Z_INDIRECT_P(variable_ptr);
+       }
+
+       value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (UNEXPECTED(Z_TYPE(variable) != IS_INDIRECT)) {
+               zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
+               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+               zval_ptr_dtor_nogc(free_op2);
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (IS_CV == IS_VAR &&
+                  opline->extended_value == ZEND_RETURNS_FUNCTION &&
+                          UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
+                               Z_INDIRECT_P(variable_ptr), value_ptr, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC))) {
+                       if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                       zval_ptr_dtor_nogc(free_op2);
+
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+               zval_ptr_dtor_nogc(free_op2);
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               zend_property_info *prop_info = NULL;
+
+               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
+               } else {
+                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
+               }
+
+               if (UNEXPECTED(prop_info)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               zval_ptr_dtor_nogc(free_op2);
+
+                               HANDLE_EXCEPTION();
+                       }
+
+                       if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr)) && Z_ISREF_P(variable_ptr)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+                       }
+               }
+               zend_assign_to_variable_reference(variable_ptr, value_ptr);
+               if (prop_info) {
+                       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               }
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+       }
+
+       if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+       zval_ptr_dtor_nogc(free_op2);
+
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -26405,7 +29898,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNU
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
+               value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
                if (UNEXPECTED(0)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -26433,7 +29926,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USE
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
+               value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
                if (UNEXPECTED(1)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -26635,7 +30128,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNU
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
+               value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
                if (UNEXPECTED(0)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -26663,7 +30156,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USE
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
+               value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
                if (UNEXPECTED(1)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -26690,7 +30183,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLE
        } else if (IS_VAR == IS_VAR &&
                   UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
 
-               zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
+               zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
                if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
                if (UNEXPECTED(free_op2)) {zval_ptr_dtor_nogc(free_op2);};
                UNDEF_RESULT();
@@ -26861,6 +30354,58 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEN
        ZEND_VM_RETURN();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_static_prop_helper_SPEC_VAR_UNUSED(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       /* This helper actually never will receive IS_VAR as second op, and has the same handling for VAR and TMP in the first op, but for interoperability with the other binary_assign_op helpers, it is necessary to "include" it */
+
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zend_reference *ref;
+       zend_bool is_typed_ref = 0;
+
+       SAVE_OPLINE();
+
+       if (UNEXPECTED(zend_fetch_static_property_address(&prop, &prop_info, (opline+1)->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
+               ZEND_ASSERT(EG(exception));
+               UNDEF_RESULT();
+               FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
+               HANDLE_EXCEPTION();
+       }
+
+       value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data);
+
+       if (UNEXPECTED(Z_ISREF_P(prop))) {
+               ref = Z_REF_P(prop);
+               is_typed_ref = ZEND_REF_HAS_TYPE_SOURCES(ref);
+               prop = Z_REFVAL_P(prop);
+       }
+
+       if (UNEXPECTED(prop_info->type || is_typed_ref)) {
+               /* special case for typed properties */
+               zval z_copy;
+
+               binary_op(&z_copy, prop, value);
+               if (EXPECTED(is_typed_ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(prop);
+                       ZVAL_COPY_VALUE(prop, &z_copy);
+               } else {
+                       zval_ptr_dtor(&z_copy);
+               }
+       } else {
+               binary_op(prop, prop, value);
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+       }
+
+       FREE_OP(free_op_data);
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
@@ -26891,12 +30436,32 @@ assign_dim_op_new_array:
                        if (UNEXPECTED(!var_ptr)) {
                                goto assign_dim_op_ret_null;
                        }
-                       ZVAL_DEREF(var_ptr);
                }
 
                value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
-               binary_op(var_ptr, var_ptr, value);
+               if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
+                       zend_reference *ref = Z_REF_P(var_ptr);
+                       var_ptr = Z_REFVAL_P(var_ptr);
+                       if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                               zval tmp;
+                               binary_op(&tmp, var_ptr, value);
+                               if (EXPECTED(zend_verify_ref_assignable_zval(ref, &tmp, EX_USES_STRICT_TYPES()))) {
+                                       zval_ptr_dtor(var_ptr);
+                                       ZVAL_COPY_VALUE(var_ptr, &tmp);
+                               } else {
+                                       zval_ptr_dtor(&tmp);
+
+                                       FREE_OP(free_op_data1);
+                                       if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                                       HANDLE_EXCEPTION();
+                               }
+                       } else {
+                               binary_op(var_ptr, var_ptr, value);
+                       }
+               } else {
+                       binary_op(var_ptr, var_ptr, value);
+               }
 
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -26953,8 +30518,14 @@ assign_dim_op_ret_null:
 
 static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_VAR_UNUSED_DIM(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
-#if 1 && IS_UNUSED == IS_UNUSED
-       ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#if 1 && (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && (IS_UNUSED == IS_UNUSED)
+       if (EXPECTED(1)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 #else
 # if 0 || IS_VAR != IS_UNUSED
 #  if 0
@@ -26968,6 +30539,45 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
        if (EXPECTED(1)) {
                ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
        }
+#  if 0 || IS_UNUSED == IS_CONST || IS_UNUSED == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
+# endif
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#endif
+}
+
+static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_VAR_UNUSED_STATIC_PROP(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+#if 1 && (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && (IS_UNUSED == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#else
+# if 0 || IS_VAR != IS_UNUSED
+#  if 0
+       /* opline->extended_value checks are specialized, don't need opline */
+       USE_OPLINE
+#  endif
+
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_simple_helper_SPEC_VAR_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  if 0 || IS_UNUSED == IS_CONST || IS_UNUSED == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(1)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
 # endif
 
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -26979,61 +30589,121 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_DIM
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_UNUSED_DIM(add_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_UNUSED_STATIC_PROP(add_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_UNUSED_DIM(sub_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_UNUSED_STATIC_PROP(sub_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_UNUSED_DIM(mul_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_UNUSED_STATIC_PROP(mul_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_UNUSED_DIM(div_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_UNUSED_STATIC_PROP(div_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_UNUSED_DIM(mod_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_UNUSED_STATIC_PROP(mod_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_UNUSED_DIM(shift_left_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_UNUSED_STATIC_PROP(shift_left_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_UNUSED_DIM(shift_right_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_UNUSED_STATIC_PROP(shift_right_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_UNUSED_DIM(concat_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_UNUSED_STATIC_PROP(concat_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_UNUSED_DIM(bitwise_or_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_UNUSED_STATIC_PROP(bitwise_or_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_UNUSED_DIM(bitwise_and_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_UNUSED_STATIC_PROP(bitwise_and_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_UNUSED_DIM(bitwise_xor_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_UNUSED_STATIC_PROP(bitwise_xor_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_UNUSED_DIM(pow_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_VAR_UNUSED_STATIC_PROP(pow_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -27087,14 +30757,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -27136,7 +30806,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = RT_CONSTANT((opline+1), (opline+1)->op1);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -27171,6 +30841,15 @@ try_assign_dim_array:
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+
+
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -27197,14 +30876,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -27246,7 +30925,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -27282,6 +30961,15 @@ try_assign_dim_array:
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+
+                               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -27308,14 +30996,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -27357,7 +31045,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -27393,6 +31081,15 @@ try_assign_dim_array:
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+
+                               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -27419,14 +31116,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -27468,7 +31165,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_CV);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -27503,6 +31200,15 @@ try_assign_dim_array:
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+
+
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -28186,11 +31892,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDL
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CV(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
-       zend_free_op free_op1, free_op_data1;
+       zend_free_op free_op1, free_op_data;
        zval *object;
        zval *property;
        zval *value;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
@@ -28202,41 +31910,68 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        do {
-               value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
+               value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data);
 
                if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto assign_op_object;
-                               }
+                               goto assign_op_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 assign_op_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        } else {
-                               ZVAL_DEREF(zptr);
+                               zval *orig_zptr = zptr;
+                               zend_reference *ref;
+                               zend_bool is_typed_ref = 0;
+
+                               if (UNEXPECTED(Z_ISREF_P(zptr))) {
+                                       ref = Z_REF_P(zptr);
+                                       is_typed_ref = ZEND_REF_HAS_TYPE_SOURCES(ref);
+                                       zptr = Z_REFVAL_P(zptr);
+                               }
+
+                               if (IS_CV == IS_CONST) {
+                                       prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
+                               } else {
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
+                               }
+                               if (UNEXPECTED(prop_info || is_typed_ref)) {
+                                       /* special case for typed properties */
+                                       zval z_copy;
+
+                                       binary_op(&z_copy, zptr, value);
+                                       if (EXPECTED(is_typed_ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(zptr);
+                                               ZVAL_COPY_VALUE(zptr, &z_copy);
+                                       } else {
+                                               zval_ptr_dtor(&z_copy);
+                                       }
+                               } else {
+                                       binary_op(zptr, zptr, value);
+                               }
 
-                               binary_op(zptr, zptr, value);
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), zptr);
                                }
                        }
                } else {
-                       zend_assign_op_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL), value, binary_op OPLINE_CC EXECUTE_DATA_CC);
+                       zend_assign_op_overloaded_property(object, property, cache_slot, value, binary_op OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
-       FREE_OP(free_op_data1);
+       FREE_OP(free_op_data);
 
        if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
        /* assign_obj has two opcodes! */
@@ -28273,12 +32008,32 @@ assign_dim_op_new_array:
                        if (UNEXPECTED(!var_ptr)) {
                                goto assign_dim_op_ret_null;
                        }
-                       ZVAL_DEREF(var_ptr);
                }
 
                value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
-               binary_op(var_ptr, var_ptr, value);
+               if (IS_CV != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
+                       zend_reference *ref = Z_REF_P(var_ptr);
+                       var_ptr = Z_REFVAL_P(var_ptr);
+                       if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                               zval tmp;
+                               binary_op(&tmp, var_ptr, value);
+                               if (EXPECTED(zend_verify_ref_assignable_zval(ref, &tmp, EX_USES_STRICT_TYPES()))) {
+                                       zval_ptr_dtor(var_ptr);
+                                       ZVAL_COPY_VALUE(var_ptr, &tmp);
+                               } else {
+                                       zval_ptr_dtor(&tmp);
+
+                                       FREE_OP(free_op_data1);
+                                       if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                                       HANDLE_EXCEPTION();
+                               }
+                       } else {
+                               binary_op(var_ptr, var_ptr, value);
+                       }
+               } else {
+                       binary_op(var_ptr, var_ptr, value);
+               }
 
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -28349,9 +32104,25 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_simple_helper
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               ZVAL_DEREF(var_ptr);
+               zend_reference *ref = NULL;
+               if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+                       ref = Z_REF_P(var_ptr);
+                       var_ptr = Z_REFVAL_P(var_ptr);
+               }
+
+               if (UNEXPECTED(ref && ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                       zval tmp;
+                       binary_op(&tmp, var_ptr, value);
 
-               binary_op(var_ptr, var_ptr, value);
+                       if (UNEXPECTED(zend_verify_ref_assignable_zval(ref, &tmp, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(var_ptr);
+                               ZVAL_COPY_VALUE(var_ptr, &tmp);
+                       } else {
+                               zval_ptr_dtor(&tmp);
+                       }
+               } else {
+                       binary_op(var_ptr, var_ptr, value);
+               }
 
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -28364,8 +32135,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_simple_helper
 
 static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_VAR_CV(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
-#if 1 && IS_CV == IS_UNUSED
-       ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#if 1 && (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && (IS_CV == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 #else
 # if 0 || IS_VAR != IS_UNUSED
 #  if 0
@@ -28379,6 +32156,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
        if (EXPECTED(0)) {
                ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
        }
+#  if 0 || IS_CV == IS_CONST || IS_CV == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
 # endif
 
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_VAR_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -28387,8 +32169,14 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
 
 static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_VAR_CV_DIM(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
-#if 1 && IS_CV == IS_UNUSED
-       ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#if 1 && (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && (IS_CV == IS_UNUSED)
+       if (EXPECTED(1)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 #else
 # if 0 || IS_VAR != IS_UNUSED
 #  if 0
@@ -28402,6 +32190,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
        if (EXPECTED(1)) {
                ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
        }
+#  if 0 || IS_CV == IS_CONST || IS_CV == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
 # endif
 
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_VAR_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -28410,8 +32203,14 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
 
 static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_VAR_CV_OBJ(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
-#if 1 && IS_CV == IS_UNUSED
-       ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#if 1 && (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && (IS_CV == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 #else
 # if 0 || IS_VAR != IS_UNUSED
 #  if 0
@@ -28425,6 +32224,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
        if (EXPECTED(0)) {
                ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_VAR_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
        }
+#  if 0 || IS_CV == IS_CONST || IS_CV == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_VAR_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
 # endif
 
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_VAR_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -28618,6 +32422,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
        zval *object;
        zval *property;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
@@ -28630,46 +32436,34 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
 
        do {
                if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto pre_incdec_object;
-                               }
+                               goto pre_incdec_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 pre_incdec_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        } else {
-                               if (EXPECTED(Z_TYPE_P(zptr) == IS_LONG)) {
-                                       if (inc) {
-                                               fast_long_increment_function(zptr);
-                                       } else {
-                                               fast_long_decrement_function(zptr);
-                                       }
+                               if (IS_CV == IS_CONST) {
+                                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
                                } else {
-                                       ZVAL_DEREF(zptr);
-
-                                       if (inc) {
-                                               increment_function(zptr);
-                                       } else {
-                                               decrement_function(zptr);
-                                       }
-                               }
-                               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                                       ZVAL_COPY(EX_VAR(opline->result.var), zptr);
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
                                }
+                               zend_pre_incdec_property_zval(zptr, prop_info, inc OPLINE_CC EXECUTE_DATA_CC);
                        }
                } else {
-                       zend_pre_incdec_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc OPLINE_CC EXECUTE_DATA_CC);
+                       zend_pre_incdec_overloaded_property(object, property, cache_slot, inc OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
@@ -28694,6 +32488,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
        zval *object;
        zval *property;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
@@ -28706,42 +32502,33 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
 
        do {
                if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto post_incdec_object;
-                               }
+                               goto post_incdec_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 post_incdec_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
                        } else {
-                               if (EXPECTED(Z_TYPE_P(zptr) == IS_LONG)) {
-                                       ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(zptr));
-                                       if (inc) {
-                                               fast_long_increment_function(zptr);
-                                       } else {
-                                               fast_long_decrement_function(zptr);
-                                       }
+                               if (IS_CV == IS_CONST) {
+                                       prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
                                } else {
-                                       ZVAL_DEREF(zptr);
-                                       ZVAL_COPY(EX_VAR(opline->result.var), zptr);
-                                       if (inc) {
-                                               increment_function(zptr);
-                                       } else {
-                                               decrement_function(zptr);
-                                       }
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
                                }
+
+                               zend_post_incdec_property_zval(zptr, prop_info, inc OPLINE_CC EXECUTE_DATA_CC);
                        }
                } else {
-                       zend_post_incdec_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc OPLINE_CC EXECUTE_DATA_CC);
+                       zend_post_incdec_overloaded_property(object, property, cache_slot, inc OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
@@ -28840,7 +32627,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLE
 
        property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_W OPLINE_CC);
+       zend_fetch_property_address(
+               result, container, IS_VAR, property, IS_CV,
+               ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
+               BP_VAR_W, opline->extended_value & ZEND_FETCH_OBJ_FLAGS, 1 OPLINE_CC);
 
        if (IS_VAR == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -28862,7 +32652,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDL
        }
        property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW OPLINE_CC);
+       zend_fetch_property_address(result, container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, 1 OPLINE_CC);
 
        if (IS_VAR == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -28877,7 +32667,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV
                if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
                        ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
                }
-
                ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
                ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -28899,7 +32688,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HA
 
        property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET OPLINE_CC);
+       zend_fetch_property_address(result, container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, 1 OPLINE_CC);
 
        if (IS_VAR == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -28947,13 +32736,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
 
        if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
 
                        goto exit_assign_obj;
                }
@@ -28962,15 +32750,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA
 assign_object:
        if (IS_CV == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_CONST & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_CONST & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+
+                                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_CONST == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_CONST & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_CONST);
+                                       value = zend_assign_to_variable(property_val, value, IS_CONST, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -29032,10 +32859,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
 
 exit_assign_obj:
@@ -29062,13 +32889,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA
        value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
                        zval_ptr_dtor_nogc(free_op_data);
                        goto exit_assign_obj;
                }
@@ -29077,15 +32903,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA
 assign_object:
        if (IS_CV == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_TMP_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_TMP_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+
+                                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_TMP_VAR == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_TMP_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_TMP_VAR);
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -29147,10 +33012,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
        zval_ptr_dtor_nogc(free_op_data);
 exit_assign_obj:
@@ -29177,13 +33042,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA
        value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
                        zval_ptr_dtor_nogc(free_op_data);
                        goto exit_assign_obj;
                }
@@ -29192,15 +33056,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA
 assign_object:
        if (IS_CV == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+
+                                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_VAR == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_VAR);
+                                       value = zend_assign_to_variable(property_val, value, IS_VAR, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -29262,10 +33165,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
        zval_ptr_dtor_nogc(free_op_data);
 exit_assign_obj:
@@ -29292,13 +33195,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA
        value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
        if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
 
                        goto exit_assign_obj;
                }
@@ -29307,15 +33209,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA
 assign_object:
        if (IS_CV == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_CV & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_CV & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+
+                                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_CV == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_CV & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_CV);
+                                       value = zend_assign_to_variable(property_val, value, IS_CV, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -29377,10 +33318,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
 
 exit_assign_obj:
@@ -29394,14 +33335,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -29443,7 +33384,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = RT_CONSTANT((opline+1), (opline+1)->op1);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -29478,6 +33419,15 @@ try_assign_dim_array:
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+
+
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -29504,14 +33454,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -29553,7 +33503,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -29589,6 +33539,15 @@ try_assign_dim_array:
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+
+                               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -29615,14 +33574,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -29664,7 +33623,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -29700,6 +33659,15 @@ try_assign_dim_array:
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+
+                               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -29726,14 +33694,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -29775,7 +33743,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_CV);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -29810,6 +33778,15 @@ try_assign_dim_array:
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+
+
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -29849,7 +33826,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUS
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_CV);
+               value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
                if (UNEXPECTED(0)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -29877,7 +33854,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_CV);
+               value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
                if (UNEXPECTED(1)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -29904,7 +33881,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER
        } else if (IS_VAR == IS_VAR &&
                   UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
 
-               zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
+               zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
                if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
 
                UNDEF_RESULT();
@@ -29936,6 +33913,194 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1, free_op_data;
+       zval *property;
+       zval *container;
+       zval variable, *variable_ptr = &variable;
+       zval *value_ptr;
+       void **cache_addr;
+
+       SAVE_OPLINE();
+
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+
+       if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
+               ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       }
+
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+
+       cache_addr = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
+
+       zend_fetch_property_address(variable_ptr, container, IS_VAR, property, IS_CV, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC);
+       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
+               variable_ptr = Z_INDIRECT_P(variable_ptr);
+       }
+
+       value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (UNEXPECTED(Z_TYPE(variable) != IS_INDIRECT)) {
+               zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
+               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+
+               if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (IS_VAR == IS_VAR &&
+                  opline->extended_value == ZEND_RETURNS_FUNCTION &&
+                          UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
+                               Z_INDIRECT_P(variable_ptr), value_ptr, IS_CV OPLINE_CC EXECUTE_DATA_CC))) {
+                       if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+
+                       if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               zend_property_info *prop_info = NULL;
+
+               if (IS_CV == IS_CONST) {
+                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
+               } else {
+                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
+               }
+
+               if (UNEXPECTED(prop_info)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+
+                               if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+                               HANDLE_EXCEPTION();
+                       }
+
+                       if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr)) && Z_ISREF_P(variable_ptr)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+                       }
+               }
+               zend_assign_to_variable_reference(variable_ptr, value_ptr);
+               if (prop_info) {
+                       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               }
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+       }
+
+       if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+
+       if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *property;
+       zval *container;
+       zval variable, *variable_ptr = &variable;
+       zval *value_ptr;
+       void **cache_addr;
+
+       SAVE_OPLINE();
+
+       container = _get_zval_ptr_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+
+       if (IS_VAR == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
+               ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       }
+
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+
+       cache_addr = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
+
+       zend_fetch_property_address(variable_ptr, container, IS_VAR, property, IS_CV, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC);
+       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
+               variable_ptr = Z_INDIRECT_P(variable_ptr);
+       }
+
+       value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (UNEXPECTED(Z_TYPE(variable) != IS_INDIRECT)) {
+               zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
+               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (IS_CV == IS_VAR &&
+                  opline->extended_value == ZEND_RETURNS_FUNCTION &&
+                          UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
+                               Z_INDIRECT_P(variable_ptr), value_ptr, IS_CV OPLINE_CC EXECUTE_DATA_CC))) {
+                       if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+
+
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               zend_property_info *prop_info = NULL;
+
+               if (IS_CV == IS_CONST) {
+                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
+               } else {
+                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
+               }
+
+               if (UNEXPECTED(prop_info)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+                               if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+
+
+                               HANDLE_EXCEPTION();
+                       }
+
+                       if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr)) && Z_ISREF_P(variable_ptr)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+                       }
+               }
+               zend_assign_to_variable_reference(variable_ptr, value_ptr);
+               if (prop_info) {
+                       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               }
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+       }
+
+       if (UNEXPECTED(free_op1)) {zval_ptr_dtor_nogc(free_op1);};
+
+
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -30497,7 +34662,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_R_SIMPLE_
        }
 
        variable_ptr = EX_VAR(opline->op2.var);
-       zend_assign_to_variable(variable_ptr, value, IS_CV);
+       zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
@@ -30549,7 +34714,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_R_SIMPLE_
        }
 
        variable_ptr = EX_VAR(opline->op2.var);
-       zend_assign_to_variable(variable_ptr, value, IS_CV);
+       zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
@@ -30735,11 +34900,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_H
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
-       zend_free_op free_op_data1;
+       zend_free_op free_op_data;
        zval *object;
        zval *property;
        zval *value;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = &EX(This);
@@ -30751,41 +34918,68 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        property = RT_CONSTANT(opline, opline->op2);
 
        do {
-               value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
+               value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data);
 
                if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto assign_op_object;
-                               }
+                               goto assign_op_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 assign_op_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        } else {
-                               ZVAL_DEREF(zptr);
+                               zval *orig_zptr = zptr;
+                               zend_reference *ref;
+                               zend_bool is_typed_ref = 0;
+
+                               if (UNEXPECTED(Z_ISREF_P(zptr))) {
+                                       ref = Z_REF_P(zptr);
+                                       is_typed_ref = ZEND_REF_HAS_TYPE_SOURCES(ref);
+                                       zptr = Z_REFVAL_P(zptr);
+                               }
+
+                               if (IS_CONST == IS_CONST) {
+                                       prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
+                               } else {
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
+                               }
+                               if (UNEXPECTED(prop_info || is_typed_ref)) {
+                                       /* special case for typed properties */
+                                       zval z_copy;
+
+                                       binary_op(&z_copy, zptr, value);
+                                       if (EXPECTED(is_typed_ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(zptr);
+                                               ZVAL_COPY_VALUE(zptr, &z_copy);
+                                       } else {
+                                               zval_ptr_dtor(&z_copy);
+                                       }
+                               } else {
+                                       binary_op(zptr, zptr, value);
+                               }
 
-                               binary_op(zptr, zptr, value);
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), zptr);
                                }
                        }
                } else {
-                       zend_assign_op_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL), value, binary_op OPLINE_CC EXECUTE_DATA_CC);
+                       zend_assign_op_overloaded_property(object, property, cache_slot, value, binary_op OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
-       FREE_OP(free_op_data1);
+       FREE_OP(free_op_data);
 
 
        /* assign_obj has two opcodes! */
@@ -30794,8 +34988,14 @@ assign_op_object:
 
 static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_UNUSED_CONST_OBJ(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
-#if 1 && IS_CONST == IS_UNUSED
-       ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#if 1 && (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_UNUSED_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && (IS_CONST == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_UNUSED_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 #else
 # if 0 || IS_UNUSED != IS_UNUSED
 #  if 0
@@ -30809,6 +35009,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
        if (EXPECTED(0)) {
                ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
        }
+#  if 0 || IS_CONST == IS_CONST || IS_CONST == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_UNUSED_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
 # endif
 
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -30882,6 +35087,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
        zval *object;
        zval *property;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = &EX(This);
@@ -30894,46 +35101,34 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
 
        do {
                if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto pre_incdec_object;
-                               }
+                               goto pre_incdec_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 pre_incdec_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        } else {
-                               if (EXPECTED(Z_TYPE_P(zptr) == IS_LONG)) {
-                                       if (inc) {
-                                               fast_long_increment_function(zptr);
-                                       } else {
-                                               fast_long_decrement_function(zptr);
-                                       }
+                               if (IS_CONST == IS_CONST) {
+                                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
                                } else {
-                                       ZVAL_DEREF(zptr);
-
-                                       if (inc) {
-                                               increment_function(zptr);
-                                       } else {
-                                               decrement_function(zptr);
-                                       }
-                               }
-                               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                                       ZVAL_COPY(EX_VAR(opline->result.var), zptr);
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
                                }
+                               zend_pre_incdec_property_zval(zptr, prop_info, inc OPLINE_CC EXECUTE_DATA_CC);
                        }
                } else {
-                       zend_pre_incdec_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc OPLINE_CC EXECUTE_DATA_CC);
+                       zend_pre_incdec_overloaded_property(object, property, cache_slot, inc OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
@@ -30958,6 +35153,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
        zval *object;
        zval *property;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = &EX(This);
@@ -30970,42 +35167,33 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
 
        do {
                if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto post_incdec_object;
-                               }
+                               goto post_incdec_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 post_incdec_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
                        } else {
-                               if (EXPECTED(Z_TYPE_P(zptr) == IS_LONG)) {
-                                       ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(zptr));
-                                       if (inc) {
-                                               fast_long_increment_function(zptr);
-                                       } else {
-                                               fast_long_decrement_function(zptr);
-                                       }
+                               if (IS_CONST == IS_CONST) {
+                                       prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
                                } else {
-                                       ZVAL_DEREF(zptr);
-                                       ZVAL_COPY(EX_VAR(opline->result.var), zptr);
-                                       if (inc) {
-                                               increment_function(zptr);
-                                       } else {
-                                               decrement_function(zptr);
-                                       }
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
                                }
+
+                               zend_post_incdec_property_zval(zptr, prop_info, inc OPLINE_CC EXECUTE_DATA_CC);
                        }
                } else {
-                       zend_post_incdec_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc OPLINE_CC EXECUTE_DATA_CC);
+                       zend_post_incdec_overloaded_property(object, property, cache_slot, inc OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
@@ -31068,7 +35256,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_U
                zval *retval;
 
                if (IS_CONST == IS_CONST) {
-                       cache_slot = CACHE_ADDR(opline->extended_value);
+                       cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
                                uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
@@ -31139,7 +35327,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_
 
        property = RT_CONSTANT(opline, opline->op2);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_W OPLINE_CC);
+       zend_fetch_property_address(
+               result, container, IS_UNUSED, property, IS_CONST,
+               ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
+               BP_VAR_W, opline->extended_value & ZEND_FETCH_OBJ_FLAGS, 1 OPLINE_CC);
 
        if (IS_UNUSED == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -31161,7 +35352,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST
        }
        property = RT_CONSTANT(opline, opline->op2);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW OPLINE_CC);
+       zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, 1 OPLINE_CC);
 
        if (IS_UNUSED == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -31266,7 +35457,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED
                if ((IS_UNUSED & (IS_CONST|IS_TMP_VAR))) {
                        ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
                }
-
                ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
                ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -31288,7 +35478,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CO
 
        property = RT_CONSTANT(opline, opline->op2);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET OPLINE_CC);
+       zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, 1 OPLINE_CC);
 
        if (IS_UNUSED == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -31313,13 +35503,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
 
        if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
 
                        goto exit_assign_obj;
                }
@@ -31328,15 +35517,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O
 assign_object:
        if (IS_CONST == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_CONST & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_CONST & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+
+
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_CONST == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_CONST & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_CONST);
+                                       value = zend_assign_to_variable(property_val, value, IS_CONST, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -31398,10 +35626,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
 
 exit_assign_obj:
@@ -31428,13 +35656,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O
        value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
                        zval_ptr_dtor_nogc(free_op_data);
                        goto exit_assign_obj;
                }
@@ -31443,15 +35670,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O
 assign_object:
        if (IS_CONST == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_TMP_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_TMP_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+
+
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_TMP_VAR == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_TMP_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_TMP_VAR);
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -31513,10 +35779,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
        zval_ptr_dtor_nogc(free_op_data);
 exit_assign_obj:
@@ -31543,13 +35809,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O
        value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
                        zval_ptr_dtor_nogc(free_op_data);
                        goto exit_assign_obj;
                }
@@ -31558,15 +35823,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O
 assign_object:
        if (IS_CONST == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+
+
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_VAR == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_VAR);
+                                       value = zend_assign_to_variable(property_val, value, IS_VAR, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -31628,10 +35932,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
        zval_ptr_dtor_nogc(free_op_data);
 exit_assign_obj:
@@ -31658,13 +35962,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O
        value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
        if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
 
                        goto exit_assign_obj;
                }
@@ -31673,15 +35976,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O
 assign_object:
        if (IS_CONST == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_CV & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_CV & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+
+
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_CV == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_CV & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_CV);
+                                       value = zend_assign_to_variable(property_val, value, IS_CV, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -31743,10 +36085,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
 
 exit_assign_obj:
@@ -31756,6 +36098,192 @@ exit_assign_obj:
        ZEND_VM_NEXT_OPCODE_EX(1, 2);
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *property;
+       zval *container;
+       zval variable, *variable_ptr = &variable;
+       zval *value_ptr;
+       void **cache_addr;
+
+       SAVE_OPLINE();
+
+       container = &EX(This);
+
+       if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
+               ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       }
+
+       property = RT_CONSTANT(opline, opline->op2);
+
+       cache_addr = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
+
+       zend_fetch_property_address(variable_ptr, container, IS_UNUSED, property, IS_CONST, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC);
+       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
+               variable_ptr = Z_INDIRECT_P(variable_ptr);
+       }
+
+       value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (UNEXPECTED(Z_TYPE(variable) != IS_INDIRECT)) {
+               zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
+
+
+               if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (IS_VAR == IS_VAR &&
+                  opline->extended_value == ZEND_RETURNS_FUNCTION &&
+                          UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
+                               Z_INDIRECT_P(variable_ptr), value_ptr, IS_CONST OPLINE_CC EXECUTE_DATA_CC))) {
+
+
+                       if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+
+
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               zend_property_info *prop_info = NULL;
+
+               if (IS_CONST == IS_CONST) {
+                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
+               } else {
+                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
+               }
+
+               if (UNEXPECTED(prop_info)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+
+
+                               if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+                               HANDLE_EXCEPTION();
+                       }
+
+                       if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr)) && Z_ISREF_P(variable_ptr)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+                       }
+               }
+               zend_assign_to_variable_reference(variable_ptr, value_ptr);
+               if (prop_info) {
+                       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               }
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+       }
+
+
+       if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *property;
+       zval *container;
+       zval variable, *variable_ptr = &variable;
+       zval *value_ptr;
+       void **cache_addr;
+
+       SAVE_OPLINE();
+
+       container = &EX(This);
+
+       if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
+               ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       }
+
+       property = RT_CONSTANT(opline, opline->op2);
+
+       cache_addr = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
+
+       zend_fetch_property_address(variable_ptr, container, IS_UNUSED, property, IS_CONST, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC);
+       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
+               variable_ptr = Z_INDIRECT_P(variable_ptr);
+       }
+
+       value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (UNEXPECTED(Z_TYPE(variable) != IS_INDIRECT)) {
+               zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
+
+
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (IS_CV == IS_VAR &&
+                  opline->extended_value == ZEND_RETURNS_FUNCTION &&
+                          UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
+                               Z_INDIRECT_P(variable_ptr), value_ptr, IS_CONST OPLINE_CC EXECUTE_DATA_CC))) {
+
+
+
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+
+
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               zend_property_info *prop_info = NULL;
+
+               if (IS_CONST == IS_CONST) {
+                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
+               } else {
+                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
+               }
+
+               if (UNEXPECTED(prop_info)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+
+
+
+                               HANDLE_EXCEPTION();
+                       }
+
+                       if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr)) && Z_ISREF_P(variable_ptr)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+                       }
+               }
+               zend_assign_to_variable_reference(variable_ptr, value_ptr);
+               if (prop_info) {
+                       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               }
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+       }
+
+
+
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -32415,11 +36943,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLE
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMPVAR(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
-       zend_free_op free_op2, free_op_data1;
+       zend_free_op free_op2, free_op_data;
        zval *object;
        zval *property;
        zval *value;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = &EX(This);
@@ -32431,41 +36961,68 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        do {
-               value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
+               value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data);
 
                if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto assign_op_object;
-                               }
+                               goto assign_op_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 assign_op_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        } else {
-                               ZVAL_DEREF(zptr);
+                               zval *orig_zptr = zptr;
+                               zend_reference *ref;
+                               zend_bool is_typed_ref = 0;
+
+                               if (UNEXPECTED(Z_ISREF_P(zptr))) {
+                                       ref = Z_REF_P(zptr);
+                                       is_typed_ref = ZEND_REF_HAS_TYPE_SOURCES(ref);
+                                       zptr = Z_REFVAL_P(zptr);
+                               }
+
+                               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                                       prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
+                               } else {
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
+                               }
+                               if (UNEXPECTED(prop_info || is_typed_ref)) {
+                                       /* special case for typed properties */
+                                       zval z_copy;
+
+                                       binary_op(&z_copy, zptr, value);
+                                       if (EXPECTED(is_typed_ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(zptr);
+                                               ZVAL_COPY_VALUE(zptr, &z_copy);
+                                       } else {
+                                               zval_ptr_dtor(&z_copy);
+                                       }
+                               } else {
+                                       binary_op(zptr, zptr, value);
+                               }
 
-                               binary_op(zptr, zptr, value);
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), zptr);
                                }
                        }
                } else {
-                       zend_assign_op_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL), value, binary_op OPLINE_CC EXECUTE_DATA_CC);
+                       zend_assign_op_overloaded_property(object, property, cache_slot, value, binary_op OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
-       FREE_OP(free_op_data1);
+       FREE_OP(free_op_data);
        zval_ptr_dtor_nogc(free_op2);
 
        /* assign_obj has two opcodes! */
@@ -32474,8 +37031,14 @@ assign_op_object:
 
 static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_UNUSED_TMPVAR_OBJ(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
-#if 1 && (IS_TMP_VAR|IS_VAR) == IS_UNUSED
-       ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#if 1 && (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_UNUSED_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && ((IS_TMP_VAR|IS_VAR) == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_UNUSED_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 #else
 # if 0 || IS_UNUSED != IS_UNUSED
 #  if 0
@@ -32489,6 +37052,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
        if (EXPECTED(0)) {
                ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
        }
+#  if 0 || (IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_UNUSED_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
 # endif
 
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -32562,6 +37130,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
        zval *object;
        zval *property;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = &EX(This);
@@ -32574,46 +37144,34 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
 
        do {
                if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto pre_incdec_object;
-                               }
+                               goto pre_incdec_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 pre_incdec_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        } else {
-                               if (EXPECTED(Z_TYPE_P(zptr) == IS_LONG)) {
-                                       if (inc) {
-                                               fast_long_increment_function(zptr);
-                                       } else {
-                                               fast_long_decrement_function(zptr);
-                                       }
+                               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
                                } else {
-                                       ZVAL_DEREF(zptr);
-
-                                       if (inc) {
-                                               increment_function(zptr);
-                                       } else {
-                                               decrement_function(zptr);
-                                       }
-                               }
-                               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                                       ZVAL_COPY(EX_VAR(opline->result.var), zptr);
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
                                }
+                               zend_pre_incdec_property_zval(zptr, prop_info, inc OPLINE_CC EXECUTE_DATA_CC);
                        }
                } else {
-                       zend_pre_incdec_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc OPLINE_CC EXECUTE_DATA_CC);
+                       zend_pre_incdec_overloaded_property(object, property, cache_slot, inc OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
@@ -32639,6 +37197,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
        zval *object;
        zval *property;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = &EX(This);
@@ -32651,42 +37211,33 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
 
        do {
                if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto post_incdec_object;
-                               }
+                               goto post_incdec_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 post_incdec_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
                        } else {
-                               if (EXPECTED(Z_TYPE_P(zptr) == IS_LONG)) {
-                                       ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(zptr));
-                                       if (inc) {
-                                               fast_long_increment_function(zptr);
-                                       } else {
-                                               fast_long_decrement_function(zptr);
-                                       }
+                               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                                       prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
                                } else {
-                                       ZVAL_DEREF(zptr);
-                                       ZVAL_COPY(EX_VAR(opline->result.var), zptr);
-                                       if (inc) {
-                                               increment_function(zptr);
-                                       } else {
-                                               decrement_function(zptr);
-                                       }
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
                                }
+
+                               zend_post_incdec_property_zval(zptr, prop_info, inc OPLINE_CC EXECUTE_DATA_CC);
                        }
                } else {
-                       zend_post_incdec_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc OPLINE_CC EXECUTE_DATA_CC);
+                       zend_post_incdec_overloaded_property(object, property, cache_slot, inc OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
@@ -32750,7 +37301,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR
                zval *retval;
 
                if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-                       cache_slot = CACHE_ADDR(opline->extended_value);
+                       cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
                                uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
@@ -32821,7 +37372,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR
 
        property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_W OPLINE_CC);
+       zend_fetch_property_address(
+               result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR),
+               (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
+               BP_VAR_W, opline->extended_value & ZEND_FETCH_OBJ_FLAGS, 1 OPLINE_CC);
        zval_ptr_dtor_nogc(free_op2);
        if (IS_UNUSED == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -32843,7 +37397,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVA
        }
        property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW OPLINE_CC);
+       zend_fetch_property_address(result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, 1 OPLINE_CC);
        zval_ptr_dtor_nogc(free_op2);
        if (IS_UNUSED == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -32948,7 +37502,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED
                if ((IS_UNUSED & (IS_CONST|IS_TMP_VAR))) {
                        ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
                }
-
                ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
                ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -32970,7 +37523,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TM
 
        property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET OPLINE_CC);
+       zend_fetch_property_address(result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, 1 OPLINE_CC);
        zval_ptr_dtor_nogc(free_op2);
        if (IS_UNUSED == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -32995,13 +37548,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
 
        if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
 
                        goto exit_assign_obj;
                }
@@ -33010,15 +37562,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_
 assign_object:
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_CONST & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_CONST & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+                                               zval_ptr_dtor_nogc(free_op2);
+
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_CONST == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_CONST & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_CONST);
+                                       value = zend_assign_to_variable(property_val, value, IS_CONST, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -33080,10 +37671,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
 
 exit_assign_obj:
@@ -33110,13 +37701,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_
        value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
                        zval_ptr_dtor_nogc(free_op_data);
                        goto exit_assign_obj;
                }
@@ -33125,15 +37715,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_
 assign_object:
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_TMP_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_TMP_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+                                               zval_ptr_dtor_nogc(free_op2);
+
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_TMP_VAR == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_TMP_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_TMP_VAR);
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -33195,10 +37824,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
        zval_ptr_dtor_nogc(free_op_data);
 exit_assign_obj:
@@ -33225,13 +37854,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_
        value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
                        zval_ptr_dtor_nogc(free_op_data);
                        goto exit_assign_obj;
                }
@@ -33240,15 +37868,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_
 assign_object:
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+                                               zval_ptr_dtor_nogc(free_op2);
+
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_VAR == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_VAR);
+                                       value = zend_assign_to_variable(property_val, value, IS_VAR, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -33310,10 +37977,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
        zval_ptr_dtor_nogc(free_op_data);
 exit_assign_obj:
@@ -33340,13 +38007,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_
        value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
        if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
 
                        goto exit_assign_obj;
                }
@@ -33355,15 +38021,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_
 assign_object:
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_CV & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_CV & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+                                               zval_ptr_dtor_nogc(free_op2);
+
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_CV == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_CV & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_CV);
+                                       value = zend_assign_to_variable(property_val, value, IS_CV, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -33425,10 +38130,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
 
 exit_assign_obj:
@@ -33438,6 +38143,192 @@ exit_assign_obj:
        ZEND_VM_NEXT_OPCODE_EX(1, 2);
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op2, free_op_data;
+       zval *property;
+       zval *container;
+       zval variable, *variable_ptr = &variable;
+       zval *value_ptr;
+       void **cache_addr;
+
+       SAVE_OPLINE();
+
+       container = &EX(This);
+
+       if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
+               ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       }
+
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+
+       cache_addr = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
+
+       zend_fetch_property_address(variable_ptr, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), cache_addr, BP_VAR_W, 0, 0 OPLINE_CC);
+       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
+               variable_ptr = Z_INDIRECT_P(variable_ptr);
+       }
+
+       value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (UNEXPECTED(Z_TYPE(variable) != IS_INDIRECT)) {
+               zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
+
+               zval_ptr_dtor_nogc(free_op2);
+               if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (IS_VAR == IS_VAR &&
+                  opline->extended_value == ZEND_RETURNS_FUNCTION &&
+                          UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
+                               Z_INDIRECT_P(variable_ptr), value_ptr, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC))) {
+
+                       zval_ptr_dtor_nogc(free_op2);
+                       if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+
+               zval_ptr_dtor_nogc(free_op2);
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               zend_property_info *prop_info = NULL;
+
+               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
+               } else {
+                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
+               }
+
+               if (UNEXPECTED(prop_info)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+
+                               zval_ptr_dtor_nogc(free_op2);
+                               if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+                               HANDLE_EXCEPTION();
+                       }
+
+                       if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr)) && Z_ISREF_P(variable_ptr)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+                       }
+               }
+               zend_assign_to_variable_reference(variable_ptr, value_ptr);
+               if (prop_info) {
+                       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               }
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+       }
+
+       zval_ptr_dtor_nogc(free_op2);
+       if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op2;
+       zval *property;
+       zval *container;
+       zval variable, *variable_ptr = &variable;
+       zval *value_ptr;
+       void **cache_addr;
+
+       SAVE_OPLINE();
+
+       container = &EX(This);
+
+       if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
+               ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       }
+
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+
+       cache_addr = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
+
+       zend_fetch_property_address(variable_ptr, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), cache_addr, BP_VAR_W, 0, 0 OPLINE_CC);
+       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
+               variable_ptr = Z_INDIRECT_P(variable_ptr);
+       }
+
+       value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (UNEXPECTED(Z_TYPE(variable) != IS_INDIRECT)) {
+               zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
+
+               zval_ptr_dtor_nogc(free_op2);
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (IS_CV == IS_VAR &&
+                  opline->extended_value == ZEND_RETURNS_FUNCTION &&
+                          UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
+                               Z_INDIRECT_P(variable_ptr), value_ptr, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC))) {
+
+                       zval_ptr_dtor_nogc(free_op2);
+
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+
+               zval_ptr_dtor_nogc(free_op2);
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               zend_property_info *prop_info = NULL;
+
+               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
+               } else {
+                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
+               }
+
+               if (UNEXPECTED(prop_info)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+
+                               zval_ptr_dtor_nogc(free_op2);
+
+                               HANDLE_EXCEPTION();
+                       }
+
+                       if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr)) && Z_ISREF_P(variable_ptr)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+                       }
+               }
+               zend_assign_to_variable_reference(variable_ptr, value_ptr);
+               if (prop_info) {
+                       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               }
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+       }
+
+       zval_ptr_dtor_nogc(free_op2);
+
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -34746,11 +39637,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUS
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
-       zend_free_op free_op_data1;
+       zend_free_op free_op_data;
        zval *object;
        zval *property;
        zval *value;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = &EX(This);
@@ -34762,41 +39655,68 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        do {
-               value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
+               value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data);
 
                if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto assign_op_object;
-                               }
+                               goto assign_op_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 assign_op_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        } else {
-                               ZVAL_DEREF(zptr);
+                               zval *orig_zptr = zptr;
+                               zend_reference *ref;
+                               zend_bool is_typed_ref = 0;
+
+                               if (UNEXPECTED(Z_ISREF_P(zptr))) {
+                                       ref = Z_REF_P(zptr);
+                                       is_typed_ref = ZEND_REF_HAS_TYPE_SOURCES(ref);
+                                       zptr = Z_REFVAL_P(zptr);
+                               }
+
+                               if (IS_CV == IS_CONST) {
+                                       prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
+                               } else {
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
+                               }
+                               if (UNEXPECTED(prop_info || is_typed_ref)) {
+                                       /* special case for typed properties */
+                                       zval z_copy;
+
+                                       binary_op(&z_copy, zptr, value);
+                                       if (EXPECTED(is_typed_ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(zptr);
+                                               ZVAL_COPY_VALUE(zptr, &z_copy);
+                                       } else {
+                                               zval_ptr_dtor(&z_copy);
+                                       }
+                               } else {
+                                       binary_op(zptr, zptr, value);
+                               }
 
-                               binary_op(zptr, zptr, value);
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), zptr);
                                }
                        }
                } else {
-                       zend_assign_op_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL), value, binary_op OPLINE_CC EXECUTE_DATA_CC);
+                       zend_assign_op_overloaded_property(object, property, cache_slot, value, binary_op OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
-       FREE_OP(free_op_data1);
+       FREE_OP(free_op_data);
 
 
        /* assign_obj has two opcodes! */
@@ -34805,8 +39725,14 @@ assign_op_object:
 
 static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_UNUSED_CV_OBJ(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
-#if 1 && IS_CV == IS_UNUSED
-       ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#if 1 && (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_UNUSED_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && (IS_CV == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_UNUSED_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 #else
 # if 0 || IS_UNUSED != IS_UNUSED
 #  if 0
@@ -34820,6 +39746,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
        if (EXPECTED(0)) {
                ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
        }
+#  if 0 || IS_CV == IS_CONST || IS_CV == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_UNUSED_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
 # endif
 
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -34893,6 +39824,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
        zval *object;
        zval *property;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = &EX(This);
@@ -34905,46 +39838,34 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
 
        do {
                if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto pre_incdec_object;
-                               }
+                               goto pre_incdec_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 pre_incdec_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        } else {
-                               if (EXPECTED(Z_TYPE_P(zptr) == IS_LONG)) {
-                                       if (inc) {
-                                               fast_long_increment_function(zptr);
-                                       } else {
-                                               fast_long_decrement_function(zptr);
-                                       }
+                               if (IS_CV == IS_CONST) {
+                                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
                                } else {
-                                       ZVAL_DEREF(zptr);
-
-                                       if (inc) {
-                                               increment_function(zptr);
-                                       } else {
-                                               decrement_function(zptr);
-                                       }
-                               }
-                               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                                       ZVAL_COPY(EX_VAR(opline->result.var), zptr);
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
                                }
+                               zend_pre_incdec_property_zval(zptr, prop_info, inc OPLINE_CC EXECUTE_DATA_CC);
                        }
                } else {
-                       zend_pre_incdec_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc OPLINE_CC EXECUTE_DATA_CC);
+                       zend_pre_incdec_overloaded_property(object, property, cache_slot, inc OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
@@ -34969,6 +39890,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
        zval *object;
        zval *property;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = &EX(This);
@@ -34981,42 +39904,33 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
 
        do {
                if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto post_incdec_object;
-                               }
+                               goto post_incdec_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 post_incdec_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
                        } else {
-                               if (EXPECTED(Z_TYPE_P(zptr) == IS_LONG)) {
-                                       ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(zptr));
-                                       if (inc) {
-                                               fast_long_increment_function(zptr);
-                                       } else {
-                                               fast_long_decrement_function(zptr);
-                                       }
+                               if (IS_CV == IS_CONST) {
+                                       prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
                                } else {
-                                       ZVAL_DEREF(zptr);
-                                       ZVAL_COPY(EX_VAR(opline->result.var), zptr);
-                                       if (inc) {
-                                               increment_function(zptr);
-                                       } else {
-                                               decrement_function(zptr);
-                                       }
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
                                }
+
+                               zend_post_incdec_property_zval(zptr, prop_info, inc OPLINE_CC EXECUTE_DATA_CC);
                        }
                } else {
-                       zend_post_incdec_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc OPLINE_CC EXECUTE_DATA_CC);
+                       zend_post_incdec_overloaded_property(object, property, cache_slot, inc OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
@@ -35079,7 +39993,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HAN
                zval *retval;
 
                if (IS_CV == IS_CONST) {
-                       cache_slot = CACHE_ADDR(opline->extended_value);
+                       cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
                                uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
@@ -35150,7 +40064,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HAN
 
        property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_W OPLINE_CC);
+       zend_fetch_property_address(
+               result, container, IS_UNUSED, property, IS_CV,
+               ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
+               BP_VAR_W, opline->extended_value & ZEND_FETCH_OBJ_FLAGS, 1 OPLINE_CC);
 
        if (IS_UNUSED == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -35172,7 +40089,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HA
        }
        property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW OPLINE_CC);
+       zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, 1 OPLINE_CC);
 
        if (IS_UNUSED == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -35277,7 +40194,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED
                if ((IS_UNUSED & (IS_CONST|IS_TMP_VAR))) {
                        ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
                }
-
                ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
                ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -35299,7 +40215,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV
 
        property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET OPLINE_CC);
+       zend_fetch_property_address(result, container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, 1 OPLINE_CC);
 
        if (IS_UNUSED == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -35324,13 +40240,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
 
        if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
 
                        goto exit_assign_obj;
                }
@@ -35339,15 +40254,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D
 assign_object:
        if (IS_CV == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_CONST & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_CONST & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+
+
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_CONST == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_CONST & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_CONST);
+                                       value = zend_assign_to_variable(property_val, value, IS_CONST, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -35409,10 +40363,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
 
 exit_assign_obj:
@@ -35439,13 +40393,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D
        value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
                        zval_ptr_dtor_nogc(free_op_data);
                        goto exit_assign_obj;
                }
@@ -35454,15 +40407,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D
 assign_object:
        if (IS_CV == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_TMP_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_TMP_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+
+
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_TMP_VAR == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_TMP_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_TMP_VAR);
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -35524,10 +40516,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
        zval_ptr_dtor_nogc(free_op_data);
 exit_assign_obj:
@@ -35554,13 +40546,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D
        value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
                        zval_ptr_dtor_nogc(free_op_data);
                        goto exit_assign_obj;
                }
@@ -35569,15 +40560,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D
 assign_object:
        if (IS_CV == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+
+
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_VAR == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_VAR);
+                                       value = zend_assign_to_variable(property_val, value, IS_VAR, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -35639,10 +40669,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
        zval_ptr_dtor_nogc(free_op_data);
 exit_assign_obj:
@@ -35669,13 +40699,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D
        value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
        if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
 
                        goto exit_assign_obj;
                }
@@ -35684,15 +40713,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D
 assign_object:
        if (IS_CV == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_CV & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_CV & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+
+
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_CV == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_CV & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_CV);
+                                       value = zend_assign_to_variable(property_val, value, IS_CV, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -35754,10 +40822,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
 
 exit_assign_obj:
@@ -35767,6 +40835,192 @@ exit_assign_obj:
        ZEND_VM_NEXT_OPCODE_EX(1, 2);
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *property;
+       zval *container;
+       zval variable, *variable_ptr = &variable;
+       zval *value_ptr;
+       void **cache_addr;
+
+       SAVE_OPLINE();
+
+       container = &EX(This);
+
+       if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
+               ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       }
+
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+
+       cache_addr = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
+
+       zend_fetch_property_address(variable_ptr, container, IS_UNUSED, property, IS_CV, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC);
+       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
+               variable_ptr = Z_INDIRECT_P(variable_ptr);
+       }
+
+       value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (UNEXPECTED(Z_TYPE(variable) != IS_INDIRECT)) {
+               zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
+
+
+               if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (IS_VAR == IS_VAR &&
+                  opline->extended_value == ZEND_RETURNS_FUNCTION &&
+                          UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
+                               Z_INDIRECT_P(variable_ptr), value_ptr, IS_CV OPLINE_CC EXECUTE_DATA_CC))) {
+
+
+                       if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+
+
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               zend_property_info *prop_info = NULL;
+
+               if (IS_CV == IS_CONST) {
+                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
+               } else {
+                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
+               }
+
+               if (UNEXPECTED(prop_info)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+
+
+                               if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+                               HANDLE_EXCEPTION();
+                       }
+
+                       if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr)) && Z_ISREF_P(variable_ptr)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+                       }
+               }
+               zend_assign_to_variable_reference(variable_ptr, value_ptr);
+               if (prop_info) {
+                       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               }
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+       }
+
+
+       if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *property;
+       zval *container;
+       zval variable, *variable_ptr = &variable;
+       zval *value_ptr;
+       void **cache_addr;
+
+       SAVE_OPLINE();
+
+       container = &EX(This);
+
+       if (IS_UNUSED == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
+               ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       }
+
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+
+       cache_addr = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
+
+       zend_fetch_property_address(variable_ptr, container, IS_UNUSED, property, IS_CV, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC);
+       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
+               variable_ptr = Z_INDIRECT_P(variable_ptr);
+       }
+
+       value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (UNEXPECTED(Z_TYPE(variable) != IS_INDIRECT)) {
+               zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
+
+
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (IS_CV == IS_VAR &&
+                  opline->extended_value == ZEND_RETURNS_FUNCTION &&
+                          UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
+                               Z_INDIRECT_P(variable_ptr), value_ptr, IS_CV OPLINE_CC EXECUTE_DATA_CC))) {
+
+
+
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+
+
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               zend_property_info *prop_info = NULL;
+
+               if (IS_CV == IS_CONST) {
+                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
+               } else {
+                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
+               }
+
+               if (UNEXPECTED(prop_info)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+
+
+
+                               HANDLE_EXCEPTION();
+                       }
+
+                       if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr)) && Z_ISREF_P(variable_ptr)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+                       }
+               }
+               zend_assign_to_variable_reference(variable_ptr, value_ptr);
+               if (prop_info) {
+                       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               }
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+       }
+
+
+
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -36408,9 +41662,35 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED_
                ZVAL_NULL(var_ptr);
                ZVAL_UNDEFINED_OP1();
        }
-       ZVAL_DEREF(var_ptr);
 
-       increment_function(var_ptr);
+       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+               zend_reference *ref = Z_REF_P(var_ptr);
+               var_ptr = Z_REFVAL_P(var_ptr);
+               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                       zval old;
+                       ZVAL_COPY(&old, var_ptr);
+
+                       increment_function(var_ptr);
+
+                       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_DOUBLE) && Z_TYPE(old) == IS_LONG) {
+                               zend_throw_incdec_ref_error(ref, 1);
+                               ZVAL_COPY_VALUE(var_ptr, &old);
+
+                               HANDLE_EXCEPTION();
+                       } else if (UNEXPECTED(!zend_verify_ref_assignable_zval(ref, var_ptr, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(var_ptr);
+                               ZVAL_COPY_VALUE(var_ptr, &old);
+
+                               HANDLE_EXCEPTION();
+                       } else {
+                               zval_ptr_dtor(&old);
+                       }
+               } else {
+                       increment_function(var_ptr);
+               }
+       } else {
+               increment_function(var_ptr);
+       }
 
        if (UNEXPECTED(0)) {
                ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -36447,9 +41727,35 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_RETVAL_USED_HA
                ZVAL_NULL(var_ptr);
                ZVAL_UNDEFINED_OP1();
        }
-       ZVAL_DEREF(var_ptr);
 
-       increment_function(var_ptr);
+       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+               zend_reference *ref = Z_REF_P(var_ptr);
+               var_ptr = Z_REFVAL_P(var_ptr);
+               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                       zval old;
+                       ZVAL_COPY(&old, var_ptr);
+
+                       increment_function(var_ptr);
+
+                       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_DOUBLE) && Z_TYPE(old) == IS_LONG) {
+                               zend_throw_incdec_ref_error(ref, 1);
+                               ZVAL_COPY_VALUE(var_ptr, &old);
+
+                               HANDLE_EXCEPTION();
+                       } else if (UNEXPECTED(!zend_verify_ref_assignable_zval(ref, var_ptr, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(var_ptr);
+                               ZVAL_COPY_VALUE(var_ptr, &old);
+
+                               HANDLE_EXCEPTION();
+                       } else {
+                               zval_ptr_dtor(&old);
+                       }
+               } else {
+                       increment_function(var_ptr);
+               }
+       } else {
+               increment_function(var_ptr);
+       }
 
        if (UNEXPECTED(1)) {
                ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -36486,9 +41792,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED_
                ZVAL_NULL(var_ptr);
                ZVAL_UNDEFINED_OP1();
        }
-       ZVAL_DEREF(var_ptr);
 
-       decrement_function(var_ptr);
+       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+               zend_reference *ref = Z_REF_P(var_ptr);
+               var_ptr = Z_REFVAL_P(var_ptr);
+
+               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                       zval old;
+                       ZVAL_COPY(&old, var_ptr);
+
+                       decrement_function(var_ptr);
+
+                       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_DOUBLE) && Z_TYPE(old) == IS_LONG) {
+                               zend_throw_incdec_ref_error(ref, 0);
+                               ZVAL_COPY_VALUE(var_ptr, &old);
+
+                               HANDLE_EXCEPTION();
+                       } else if (UNEXPECTED(!zend_verify_ref_assignable_zval(ref, var_ptr, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(var_ptr);
+                               ZVAL_COPY_VALUE(var_ptr, &old);
+
+                               HANDLE_EXCEPTION();
+                       } else {
+                               zval_ptr_dtor(&old);
+                       }
+               } else {
+                       decrement_function(var_ptr);
+               }
+       } else {
+               decrement_function(var_ptr);
+       }
 
        if (UNEXPECTED(0)) {
                ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -36525,9 +41858,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_RETVAL_USED_HA
                ZVAL_NULL(var_ptr);
                ZVAL_UNDEFINED_OP1();
        }
-       ZVAL_DEREF(var_ptr);
 
-       decrement_function(var_ptr);
+       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+               zend_reference *ref = Z_REF_P(var_ptr);
+               var_ptr = Z_REFVAL_P(var_ptr);
+
+               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                       zval old;
+                       ZVAL_COPY(&old, var_ptr);
+
+                       decrement_function(var_ptr);
+
+                       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_DOUBLE) && Z_TYPE(old) == IS_LONG) {
+                               zend_throw_incdec_ref_error(ref, 0);
+                               ZVAL_COPY_VALUE(var_ptr, &old);
+
+                               HANDLE_EXCEPTION();
+                       } else if (UNEXPECTED(!zend_verify_ref_assignable_zval(ref, var_ptr, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(var_ptr);
+                               ZVAL_COPY_VALUE(var_ptr, &old);
+
+                               HANDLE_EXCEPTION();
+                       } else {
+                               zval_ptr_dtor(&old);
+                       }
+               } else {
+                       decrement_function(var_ptr);
+               }
+       } else {
+               decrement_function(var_ptr);
+       }
 
        if (UNEXPECTED(1)) {
                ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -36560,10 +41920,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_
                ZVAL_NULL(var_ptr);
                ZVAL_UNDEFINED_OP1();
        }
-       ZVAL_DEREF(var_ptr);
-       ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 
-       increment_function(var_ptr);
+       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+               zend_reference *ref = Z_REF_P(var_ptr);
+               var_ptr = Z_REFVAL_P(var_ptr);
+
+               ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+
+               increment_function(var_ptr);
+
+               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_DOUBLE) && Z_TYPE_P(EX_VAR(opline->result.var)) == IS_LONG) {
+                               zend_throw_incdec_ref_error(ref, 1);
+                               ZVAL_COPY_VALUE(var_ptr, EX_VAR(opline->result.var));
+                       } else if (UNEXPECTED(!zend_verify_ref_assignable_zval(ref, var_ptr, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(var_ptr);
+                               ZVAL_COPY_VALUE(var_ptr, EX_VAR(opline->result.var));
+                       }
+               }
+       } else {
+               ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+
+               increment_function(var_ptr);
+       }
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -36592,10 +41971,29 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_
                ZVAL_NULL(var_ptr);
                ZVAL_UNDEFINED_OP1();
        }
-       ZVAL_DEREF(var_ptr);
-       ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 
-       decrement_function(var_ptr);
+       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+               zend_reference *ref = Z_REF_P(var_ptr);
+               var_ptr = Z_REFVAL_P(var_ptr);
+
+               ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+
+               decrement_function(var_ptr);
+
+               if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                       if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_DOUBLE) && Z_TYPE_P(EX_VAR(opline->result.var)) == IS_LONG) {
+                               zend_throw_incdec_ref_error(ref, 0);
+                               ZVAL_COPY_VALUE(var_ptr, EX_VAR(opline->result.var));
+                       } else if (UNEXPECTED(!zend_verify_ref_assignable_zval(ref, var_ptr, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(var_ptr);
+                               ZVAL_COPY_VALUE(var_ptr, EX_VAR(opline->result.var));
+                       }
+               }
+       } else {
+               ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+
+               decrement_function(var_ptr);
+       }
 
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -38660,11 +44058,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
-       zend_free_op free_op_data1;
+       zend_free_op free_op_data;
        zval *object;
        zval *property;
        zval *value;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
@@ -38676,47 +44076,126 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        property = RT_CONSTANT(opline, opline->op2);
 
        do {
-               value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
+               value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data);
 
                if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto assign_op_object;
-                               }
+                               goto assign_op_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 assign_op_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        } else {
-                               ZVAL_DEREF(zptr);
+                               zval *orig_zptr = zptr;
+                               zend_reference *ref;
+                               zend_bool is_typed_ref = 0;
+
+                               if (UNEXPECTED(Z_ISREF_P(zptr))) {
+                                       ref = Z_REF_P(zptr);
+                                       is_typed_ref = ZEND_REF_HAS_TYPE_SOURCES(ref);
+                                       zptr = Z_REFVAL_P(zptr);
+                               }
+
+                               if (IS_CONST == IS_CONST) {
+                                       prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
+                               } else {
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
+                               }
+                               if (UNEXPECTED(prop_info || is_typed_ref)) {
+                                       /* special case for typed properties */
+                                       zval z_copy;
+
+                                       binary_op(&z_copy, zptr, value);
+                                       if (EXPECTED(is_typed_ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(zptr);
+                                               ZVAL_COPY_VALUE(zptr, &z_copy);
+                                       } else {
+                                               zval_ptr_dtor(&z_copy);
+                                       }
+                               } else {
+                                       binary_op(zptr, zptr, value);
+                               }
 
-                               binary_op(zptr, zptr, value);
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), zptr);
                                }
                        }
                } else {
-                       zend_assign_op_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL), value, binary_op OPLINE_CC EXECUTE_DATA_CC);
+                       zend_assign_op_overloaded_property(object, property, cache_slot, value, binary_op OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
-       FREE_OP(free_op_data1);
+       FREE_OP(free_op_data);
 
 
        /* assign_obj has two opcodes! */
        ZEND_VM_NEXT_OPCODE_EX(1, 2);
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_static_prop_helper_SPEC_CV_CONST(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       /* This helper actually never will receive IS_VAR as second op, and has the same handling for VAR and TMP in the first op, but for interoperability with the other binary_assign_op helpers, it is necessary to "include" it */
+
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zend_reference *ref;
+       zend_bool is_typed_ref = 0;
+
+       SAVE_OPLINE();
+
+       if (UNEXPECTED(zend_fetch_static_property_address(&prop, &prop_info, (opline+1)->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
+               ZEND_ASSERT(EG(exception));
+               UNDEF_RESULT();
+               FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
+               HANDLE_EXCEPTION();
+       }
+
+       value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data);
+
+       if (UNEXPECTED(Z_ISREF_P(prop))) {
+               ref = Z_REF_P(prop);
+               is_typed_ref = ZEND_REF_HAS_TYPE_SOURCES(ref);
+               prop = Z_REFVAL_P(prop);
+       }
+
+       if (UNEXPECTED(prop_info->type || is_typed_ref)) {
+               /* special case for typed properties */
+               zval z_copy;
+
+               binary_op(&z_copy, prop, value);
+               if (EXPECTED(is_typed_ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(prop);
+                       ZVAL_COPY_VALUE(prop, &z_copy);
+               } else {
+                       zval_ptr_dtor(&z_copy);
+               }
+       } else {
+               binary_op(prop, prop, value);
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+       }
+
+       FREE_OP(free_op_data);
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_CV_CONST(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
@@ -38747,12 +44226,32 @@ assign_dim_op_new_array:
                        if (UNEXPECTED(!var_ptr)) {
                                goto assign_dim_op_ret_null;
                        }
-                       ZVAL_DEREF(var_ptr);
                }
 
                value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
-               binary_op(var_ptr, var_ptr, value);
+               if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
+                       zend_reference *ref = Z_REF_P(var_ptr);
+                       var_ptr = Z_REFVAL_P(var_ptr);
+                       if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                               zval tmp;
+                               binary_op(&tmp, var_ptr, value);
+                               if (EXPECTED(zend_verify_ref_assignable_zval(ref, &tmp, EX_USES_STRICT_TYPES()))) {
+                                       zval_ptr_dtor(var_ptr);
+                                       ZVAL_COPY_VALUE(var_ptr, &tmp);
+                               } else {
+                                       zval_ptr_dtor(&tmp);
+
+                                       FREE_OP(free_op_data1);
+
+                                       HANDLE_EXCEPTION();
+                               }
+                       } else {
+                               binary_op(var_ptr, var_ptr, value);
+                       }
+               } else {
+                       binary_op(var_ptr, var_ptr, value);
+               }
 
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -38823,9 +44322,25 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_simple_helper
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               ZVAL_DEREF(var_ptr);
+               zend_reference *ref = NULL;
+               if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+                       ref = Z_REF_P(var_ptr);
+                       var_ptr = Z_REFVAL_P(var_ptr);
+               }
+
+               if (UNEXPECTED(ref && ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                       zval tmp;
+                       binary_op(&tmp, var_ptr, value);
 
-               binary_op(var_ptr, var_ptr, value);
+                       if (UNEXPECTED(zend_verify_ref_assignable_zval(ref, &tmp, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(var_ptr);
+                               ZVAL_COPY_VALUE(var_ptr, &tmp);
+                       } else {
+                               zval_ptr_dtor(&tmp);
+                       }
+               } else {
+                       binary_op(var_ptr, var_ptr, value);
+               }
 
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -38838,8 +44353,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_simple_helper
 
 static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_CV_CONST(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
-#if 1 && IS_CONST == IS_UNUSED
-       ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#if 1 && (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && (IS_CONST == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 #else
 # if 0 || IS_CV != IS_UNUSED
 #  if 0
@@ -38853,6 +44374,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
        if (EXPECTED(0)) {
                ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
        }
+#  if 0 || IS_CONST == IS_CONST || IS_CONST == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
 # endif
 
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -38861,8 +44387,14 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
 
 static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_CV_CONST_DIM(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
-#if 1 && IS_CONST == IS_UNUSED
-       ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#if 1 && (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && (IS_CONST == IS_UNUSED)
+       if (EXPECTED(1)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 #else
 # if 0 || IS_CV != IS_UNUSED
 #  if 0
@@ -38876,6 +44408,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
        if (EXPECTED(1)) {
                ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
        }
+#  if 0 || IS_CONST == IS_CONST || IS_CONST == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
 # endif
 
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -38884,8 +44421,48 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
 
 static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_CV_CONST_OBJ(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
-#if 1 && IS_CONST == IS_UNUSED
-       ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#if 1 && (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && (IS_CONST == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#else
+# if 0 || IS_CV != IS_UNUSED
+#  if 0
+       /* opline->extended_value checks are specialized, don't need opline */
+       USE_OPLINE
+#  endif
+
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_simple_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  if 0 || IS_CONST == IS_CONST || IS_CONST == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
+# endif
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#endif
+}
+
+static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_CV_CONST_STATIC_PROP(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+#if 1 && (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && (IS_CONST == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 #else
 # if 0 || IS_CV != IS_UNUSED
 #  if 0
@@ -38899,6 +44476,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
        if (EXPECTED(0)) {
                ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
        }
+#  if 0 || IS_CONST == IS_CONST || IS_CONST == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(1)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
 # endif
 
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_CV_CONST(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -38920,6 +44502,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_CONST_OBJ_H
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST_OBJ(add_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST_STATIC_PROP(add_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST(sub_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -38935,6 +44522,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_CONST_OBJ_H
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST_OBJ(sub_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST_STATIC_PROP(sub_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST(mul_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -38950,6 +44542,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_CONST_OBJ_H
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST_OBJ(mul_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST_STATIC_PROP(mul_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST(div_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -38965,6 +44562,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_CONST_OBJ_H
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST_OBJ(div_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST_STATIC_PROP(div_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST(mod_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -38980,6 +44582,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_CONST_OBJ_H
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST_OBJ(mod_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST_STATIC_PROP(mod_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST(shift_left_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -38995,6 +44602,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_CONST_OBJ_HA
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST_OBJ(shift_left_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST_STATIC_PROP(shift_left_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST(shift_right_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -39010,6 +44622,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_CONST_OBJ_HA
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST_OBJ(shift_right_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST_STATIC_PROP(shift_right_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST(concat_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -39025,6 +44642,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_OB
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST_OBJ(concat_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST_STATIC_PROP(concat_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_or_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -39040,6 +44662,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_OBJ
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST_OBJ(bitwise_or_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST_STATIC_PROP(bitwise_or_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_and_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -39055,6 +44682,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_OB
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST_OBJ(bitwise_and_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST_STATIC_PROP(bitwise_and_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_xor_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -39070,6 +44702,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_OB
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST_OBJ(bitwise_xor_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST_STATIC_PROP(bitwise_xor_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST(pow_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -39085,6 +44722,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_CV_CONST_OBJ_H
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST_OBJ(pow_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_CV_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_CONST_STATIC_PROP(pow_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CONST(int inc ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
@@ -39092,6 +44734,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
        zval *object;
        zval *property;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
@@ -39104,46 +44748,34 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
 
        do {
                if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto pre_incdec_object;
-                               }
+                               goto pre_incdec_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 pre_incdec_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        } else {
-                               if (EXPECTED(Z_TYPE_P(zptr) == IS_LONG)) {
-                                       if (inc) {
-                                               fast_long_increment_function(zptr);
-                                       } else {
-                                               fast_long_decrement_function(zptr);
-                                       }
+                               if (IS_CONST == IS_CONST) {
+                                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
                                } else {
-                                       ZVAL_DEREF(zptr);
-
-                                       if (inc) {
-                                               increment_function(zptr);
-                                       } else {
-                                               decrement_function(zptr);
-                                       }
-                               }
-                               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                                       ZVAL_COPY(EX_VAR(opline->result.var), zptr);
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
                                }
+                               zend_pre_incdec_property_zval(zptr, prop_info, inc OPLINE_CC EXECUTE_DATA_CC);
                        }
                } else {
-                       zend_pre_incdec_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc OPLINE_CC EXECUTE_DATA_CC);
+                       zend_pre_incdec_overloaded_property(object, property, cache_slot, inc OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
@@ -39168,6 +44800,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
        zval *object;
        zval *property;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
@@ -39180,42 +44814,33 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
 
        do {
                if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto post_incdec_object;
-                               }
+                               goto post_incdec_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 post_incdec_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
                        } else {
-                               if (EXPECTED(Z_TYPE_P(zptr) == IS_LONG)) {
-                                       ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(zptr));
-                                       if (inc) {
-                                               fast_long_increment_function(zptr);
-                                       } else {
-                                               fast_long_decrement_function(zptr);
-                                       }
+                               if (IS_CONST == IS_CONST) {
+                                       prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
                                } else {
-                                       ZVAL_DEREF(zptr);
-                                       ZVAL_COPY(EX_VAR(opline->result.var), zptr);
-                                       if (inc) {
-                                               increment_function(zptr);
-                                       } else {
-                                               decrement_function(zptr);
-                                       }
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
                                }
+
+                               zend_post_incdec_property_zval(zptr, prop_info, inc OPLINE_CC EXECUTE_DATA_CC);
                        }
                } else {
-                       zend_post_incdec_overloaded_property(object, property, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc OPLINE_CC EXECUTE_DATA_CC);
+                       zend_post_incdec_overloaded_property(object, property, cache_slot, inc OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
@@ -39233,94 +44858,83 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_CV_CONST_HAN
        ZEND_VM_TAIL_CALL(zend_post_incdec_property_helper_SPEC_CV_CONST(0 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_CV_CONST(int type ZEND_OPCODE_HANDLER_ARGS_DC)
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_static_property_helper_SPEC_CV_CONST(int inc ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
-
-       zval *varname;
-       zval *retval;
-       zend_string *name, *tmp_name;
-       zend_class_entry *ce;
+       zval *prop;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
 
-       do {
-               if (IS_CONST == IS_CONST) {
-                       if (IS_CV == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value)) != NULL)) {
-                               retval = CACHED_PTR(opline->extended_value + sizeof(void*));
-                               break;
-                       } else {
-                               zval *class_name = RT_CONSTANT(opline, opline->op2);
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
 
-                               if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value)) == NULL)) {
-                                       ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
-                                       if (UNEXPECTED(ce == NULL)) {
+       zend_pre_incdec_property_zval(prop, prop_info->type ? prop_info : NULL, inc OPLINE_CC EXECUTE_DATA_CC);
 
-                                               retval = NULL;
-                                               break;
-                                       }
-                                       if (IS_CV != IS_CONST) {
-                                               CACHE_PTR(opline->extended_value, ce);
-                                       }
-                               }
-                       }
-               } else {
-                       if (IS_CONST == IS_UNUSED) {
-                               ce = zend_fetch_class(NULL, opline->op2.num);
-                               if (UNEXPECTED(ce == NULL)) {
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
 
-                                       retval = NULL;
-                                       break;
-                               }
-                       } else {
-                               ce = Z_CE_P(EX_VAR(opline->op2.var));
-                       }
-                       if (IS_CV == IS_CONST &&
-                           EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
-                               retval = CACHED_PTR(opline->extended_value + sizeof(void*));
-                               break;
-                       }
-               }
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_STATIC_PROP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_pre_incdec_static_property_helper_SPEC_CV_CONST(1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
 
-               varname = EX_VAR(opline->op1.var);
-               if (IS_CV == IS_CONST) {
-                       name = Z_STR_P(varname);
-               } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
-                       name = Z_STR_P(varname);
-                       tmp_name = NULL;
-               } else {
-                       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
-                               zval_undefined_cv(EX(opline)->op1.var EXECUTE_DATA_CC);
-                       }
-                       name = zval_get_tmp_string(varname, &tmp_name);
-               }
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_pre_incdec_static_property_helper_SPEC_CV_CONST(0 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
 
-               retval = zend_std_get_static_property(ce, name, type == BP_VAR_IS);
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_static_property_helper_SPEC_CV_CONST(int inc ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       USE_OPLINE
+       zval *prop;
+       zend_property_info *prop_info;
 
-               if (IS_CV != IS_CONST) {
-                       zend_tmp_string_release(tmp_name);
-               }
+       SAVE_OPLINE();
 
-               if (IS_CV == IS_CONST && EXPECTED(retval)) {
-                       CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, retval);
-               }
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
 
-       } while (0);
+       zend_post_incdec_property_zval(prop, prop_info->type ? prop_info : NULL, inc OPLINE_CC EXECUTE_DATA_CC);
+
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_STATIC_PROP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_post_incdec_static_property_helper_SPEC_CV_CONST(1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_STATIC_PROP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_post_incdec_static_property_helper_SPEC_CV_CONST(0 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_CV_CONST(int type ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       USE_OPLINE
+       zval *prop;
+
+       SAVE_OPLINE();
 
-       if (UNEXPECTED(retval == NULL)) {
+       if (UNEXPECTED(zend_fetch_static_property_address(&prop, NULL, opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS, type, opline->extended_value & ZEND_FETCH_OBJ_FLAGS OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
                if (EG(exception)) {
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                } else {
                        ZEND_ASSERT(type == BP_VAR_IS);
-                       retval = &EG(uninitialized_zval);
+                       prop = &EG(uninitialized_zval);
                }
        }
 
        if (type == BP_VAR_R || type == BP_VAR_IS) {
-               ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
+               ZVAL_COPY_DEREF(EX_VAR(opline->result.var), prop);
        } else {
-               ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
+               ZVAL_INDIRECT(EX_VAR(opline->result.var), prop);
        }
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -39519,7 +45133,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_C
                zval *retval;
 
                if (IS_CONST == IS_CONST) {
-                       cache_slot = CACHE_ADDR(opline->extended_value);
+                       cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
                                uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
@@ -39590,7 +45204,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HAND
 
        property = RT_CONSTANT(opline, opline->op2);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_CV, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_W OPLINE_CC);
+       zend_fetch_property_address(
+               result, container, IS_CV, property, IS_CONST,
+               ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
+               BP_VAR_W, opline->extended_value & ZEND_FETCH_OBJ_FLAGS, 1 OPLINE_CC);
 
        if (IS_CV == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -39612,7 +45229,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HAN
        }
        property = RT_CONSTANT(opline, opline->op2);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_CV, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW OPLINE_CC);
+       zend_fetch_property_address(result, container, IS_CV, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, 1 OPLINE_CC);
 
        if (IS_CV == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -39717,7 +45334,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CON
                if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
                        ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
                }
-
                ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
                ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -39739,7 +45355,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_
 
        property = RT_CONSTANT(opline, opline->op2);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_CV, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET OPLINE_CC);
+       zend_fetch_property_address(result, container, IS_CV, property, IS_CONST, ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, 1 OPLINE_CC);
 
        if (IS_CV == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -39764,13 +45380,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
 
        if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
 
                        goto exit_assign_obj;
                }
@@ -39779,15 +45394,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA
 assign_object:
        if (IS_CONST == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_CONST & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_CONST & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+
+
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_CONST == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_CONST & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_CONST);
+                                       value = zend_assign_to_variable(property_val, value, IS_CONST, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -39849,10 +45503,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
 
 exit_assign_obj:
@@ -39879,13 +45533,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA
        value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
                        zval_ptr_dtor_nogc(free_op_data);
                        goto exit_assign_obj;
                }
@@ -39894,15 +45547,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA
 assign_object:
        if (IS_CONST == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_TMP_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_TMP_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+
+
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_TMP_VAR == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_TMP_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_TMP_VAR);
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -39964,10 +45656,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
        zval_ptr_dtor_nogc(free_op_data);
 exit_assign_obj:
@@ -39994,13 +45686,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA
        value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
                        zval_ptr_dtor_nogc(free_op_data);
                        goto exit_assign_obj;
                }
@@ -40009,15 +45700,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA
 assign_object:
        if (IS_CONST == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+
+
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_VAR == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_VAR);
+                                       value = zend_assign_to_variable(property_val, value, IS_VAR, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -40079,10 +45809,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
        zval_ptr_dtor_nogc(free_op_data);
 exit_assign_obj:
@@ -40109,13 +45839,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA
        value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
 
                        goto exit_assign_obj;
                }
@@ -40124,15 +45853,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA
 assign_object:
        if (IS_CONST == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_CV & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_CV & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+
+
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_CV == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_CV & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_CV);
+                                       value = zend_assign_to_variable(property_val, value, IS_CV, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -40194,10 +45962,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
 
 exit_assign_obj:
@@ -40207,18 +45975,242 @@ exit_assign_obj:
        ZEND_VM_NEXT_OPCODE_EX(1, 2);
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_CONST & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_CONST & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_CONST & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_CONST, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_TMP_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_TMP_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_TMP_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_VAR, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_CV & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_CV & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_CV & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_CV, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
 
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = EX_VAR(opline->op1.var);
+       orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -40260,7 +46252,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = RT_CONSTANT((opline+1), (opline+1)->op1);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -40295,6 +46287,15 @@ try_assign_dim_array:
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+
+
+
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -40321,14 +46322,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA
 {
        USE_OPLINE
 
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = EX_VAR(opline->op1.var);
+       orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -40370,7 +46371,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -40406,6 +46407,15 @@ try_assign_dim_array:
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+
+                               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -40432,14 +46442,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA
 {
        USE_OPLINE
 
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = EX_VAR(opline->op1.var);
+       orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -40481,7 +46491,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -40517,6 +46527,15 @@ try_assign_dim_array:
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+
+                               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -40543,14 +46562,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DA
 {
        USE_OPLINE
 
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = EX_VAR(opline->op1.var);
+       orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -40592,7 +46611,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_CV);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -40627,6 +46646,15 @@ try_assign_dim_array:
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+
+
+
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -40666,7 +46694,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UN
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
+               value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
                if (UNEXPECTED(0)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -40694,7 +46722,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_US
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
+               value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
                if (UNEXPECTED(1)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -40705,6 +46733,244 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_US
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *property;
+       zval *container;
+       zval variable, *variable_ptr = &variable;
+       zval *value_ptr;
+       void **cache_addr;
+
+       SAVE_OPLINE();
+
+       container = EX_VAR(opline->op1.var);
+
+       if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
+               ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       }
+
+       property = RT_CONSTANT(opline, opline->op2);
+
+       cache_addr = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
+
+       zend_fetch_property_address(variable_ptr, container, IS_CV, property, IS_CONST, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC);
+       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
+               variable_ptr = Z_INDIRECT_P(variable_ptr);
+       }
+
+       value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (UNEXPECTED(Z_TYPE(variable) != IS_INDIRECT)) {
+               zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
+
+
+               if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (IS_VAR == IS_VAR &&
+                  opline->extended_value == ZEND_RETURNS_FUNCTION &&
+                          UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
+                               Z_INDIRECT_P(variable_ptr), value_ptr, IS_CONST OPLINE_CC EXECUTE_DATA_CC))) {
+
+
+                       if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+
+
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               zend_property_info *prop_info = NULL;
+
+               if (IS_CONST == IS_CONST) {
+                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
+               } else {
+                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
+               }
+
+               if (UNEXPECTED(prop_info)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+
+
+                               if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+                               HANDLE_EXCEPTION();
+                       }
+
+                       if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr)) && Z_ISREF_P(variable_ptr)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+                       }
+               }
+               zend_assign_to_variable_reference(variable_ptr, value_ptr);
+               if (prop_info) {
+                       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               }
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+       }
+
+
+       if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *property;
+       zval *container;
+       zval variable, *variable_ptr = &variable;
+       zval *value_ptr;
+       void **cache_addr;
+
+       SAVE_OPLINE();
+
+       container = EX_VAR(opline->op1.var);
+
+       if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
+               ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       }
+
+       property = RT_CONSTANT(opline, opline->op2);
+
+       cache_addr = (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
+
+       zend_fetch_property_address(variable_ptr, container, IS_CV, property, IS_CONST, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC);
+       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
+               variable_ptr = Z_INDIRECT_P(variable_ptr);
+       }
+
+       value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (UNEXPECTED(Z_TYPE(variable) != IS_INDIRECT)) {
+               zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
+
+
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (IS_CV == IS_VAR &&
+                  opline->extended_value == ZEND_RETURNS_FUNCTION &&
+                          UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
+                               Z_INDIRECT_P(variable_ptr), value_ptr, IS_CONST OPLINE_CC EXECUTE_DATA_CC))) {
+
+
+
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+
+
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               zend_property_info *prop_info = NULL;
+
+               if (IS_CONST == IS_CONST) {
+                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
+               } else {
+                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
+               }
+
+               if (UNEXPECTED(prop_info)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+
+
+
+                               HANDLE_EXCEPTION();
+                       }
+
+                       if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr)) && Z_ISREF_P(variable_ptr)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+                       }
+               }
+               zend_assign_to_variable_reference(variable_ptr, value_ptr);
+               if (prop_info) {
+                       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               }
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+       }
+
+
+
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value_ptr;
+       zend_property_info *prop_info;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value & ~ZEND_RETURNS_FUNCTION, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value_ptr = get_zval_ptr_ptr((opline+1)->op1_type, (opline+1)->op1, &free_op_data, BP_VAR_W);
+
+       if ((opline+1)->op1_type == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               prop = &EG(uninitialized_zval);
+       } else if ((opline+1)->op1_type == IS_VAR && (opline->extended_value & ZEND_RETURNS_FUNCTION) && UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(prop, value_ptr, IS_CONST OPLINE_CC EXECUTE_DATA_CC))) {
+                       if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               if (UNEXPECTED(prop_info->type)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+                               if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+                               HANDLE_EXCEPTION();
+                       }
+                       if (UNEXPECTED(Z_REFCOUNTED_P(prop)) && Z_ISREF_P(prop)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(prop), prop_info);
+                       }
+               }
+       }
+       zend_assign_to_variable_reference(prop, value_ptr);
+       if (prop_info->type) {
+               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(prop), prop_info);
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+       }
+
+       if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -41252,69 +47518,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC
        zval *value;
        int result;
 
-       zval *varname;
-       zend_string *name, *tmp_name;
-       zend_class_entry *ce;
-
        SAVE_OPLINE();
-       if (IS_CONST == IS_CONST) {
-               if (IS_CV == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY)) != NULL)) {
-                       value = CACHED_PTR((opline->extended_value & ~ZEND_ISEMPTY) + sizeof(void*));
-                       goto is_static_prop_return;
-               } else if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY)) == NULL)) {
-                       ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
-                       if (UNEXPECTED(ce == NULL)) {
-                               ZEND_ASSERT(EG(exception));
-                               ZVAL_UNDEF(EX_VAR(opline->result.var));
-                               HANDLE_EXCEPTION();
-                       }
-                       if (IS_CV != IS_CONST) {
-                               CACHE_PTR(opline->extended_value & ~ZEND_ISEMPTY, ce);
-                       }
-               }
-       } else {
-               if (IS_CONST == IS_UNUSED) {
-                       ce = zend_fetch_class(NULL, opline->op2.num);
-                       if (UNEXPECTED(ce == NULL)) {
-                               ZEND_ASSERT(EG(exception));
-
-                               ZVAL_UNDEF(EX_VAR(opline->result.var));
-                               HANDLE_EXCEPTION();
-                       }
-               } else {
-                       ce = Z_CE_P(EX_VAR(opline->op2.var));
-               }
-               if (IS_CV == IS_CONST &&
-                   EXPECTED(CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY) == ce)) {
-
-                       value = CACHED_PTR((opline->extended_value & ~ZEND_ISEMPTY) + sizeof(void*));
-                       goto is_static_prop_return;
-               }
-       }
-
-       varname = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
-       if (IS_CV == IS_CONST) {
-               name = Z_STR_P(varname);
-       } else {
-               name = zval_get_tmp_string(varname, &tmp_name);
-       }
 
-       value = zend_std_get_static_property(ce, name, 1);
-
-       if (IS_CV == IS_CONST && value) {
-               CACHE_POLYMORPHIC_PTR(opline->extended_value & ~ZEND_ISEMPTY, ce, value);
-       }
-
-       if (IS_CV != IS_CONST) {
-               zend_tmp_string_release(tmp_name);
-       }
+       result = zend_fetch_static_property_address(&value, NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0 OPLINE_CC EXECUTE_DATA_CC);
 
-is_static_prop_return:
        if (!(opline->extended_value & ZEND_ISEMPTY)) {
-               result = value && Z_TYPE_P(value) > IS_NULL &&
+               result = result == SUCCESS && Z_TYPE_P(value) > IS_NULL &&
                    (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
        } else {
-               result = !value || !i_zend_is_true(value);
+               result = result != SUCCESS || !i_zend_is_true(value);
        }
 
        ZEND_VM_SMART_BRANCH(result, 1);
@@ -42532,11 +48744,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLE
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_TMPVAR(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
-       zend_free_op free_op2, free_op_data1;
+       zend_free_op free_op2, free_op_data;
        zval *object;
        zval *property;
        zval *value;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
@@ -42548,47 +48762,126 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
 
        do {
-               value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
+               value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data);
 
                if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto assign_op_object;
-                               }
+                               goto assign_op_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 assign_op_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        } else {
-                               ZVAL_DEREF(zptr);
+                               zval *orig_zptr = zptr;
+                               zend_reference *ref;
+                               zend_bool is_typed_ref = 0;
+
+                               if (UNEXPECTED(Z_ISREF_P(zptr))) {
+                                       ref = Z_REF_P(zptr);
+                                       is_typed_ref = ZEND_REF_HAS_TYPE_SOURCES(ref);
+                                       zptr = Z_REFVAL_P(zptr);
+                               }
+
+                               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                                       prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
+                               } else {
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
+                               }
+                               if (UNEXPECTED(prop_info || is_typed_ref)) {
+                                       /* special case for typed properties */
+                                       zval z_copy;
+
+                                       binary_op(&z_copy, zptr, value);
+                                       if (EXPECTED(is_typed_ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(zptr);
+                                               ZVAL_COPY_VALUE(zptr, &z_copy);
+                                       } else {
+                                               zval_ptr_dtor(&z_copy);
+                                       }
+                               } else {
+                                       binary_op(zptr, zptr, value);
+                               }
 
-                               binary_op(zptr, zptr, value);
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), zptr);
                                }
                        }
                } else {
-                       zend_assign_op_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL), value, binary_op OPLINE_CC EXECUTE_DATA_CC);
+                       zend_assign_op_overloaded_property(object, property, cache_slot, value, binary_op OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
-       FREE_OP(free_op_data1);
+       FREE_OP(free_op_data);
        zval_ptr_dtor_nogc(free_op2);
 
        /* assign_obj has two opcodes! */
        ZEND_VM_NEXT_OPCODE_EX(1, 2);
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_static_prop_helper_SPEC_CV_TMPVAR(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       /* This helper actually never will receive IS_VAR as second op, and has the same handling for VAR and TMP in the first op, but for interoperability with the other binary_assign_op helpers, it is necessary to "include" it */
+
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zend_reference *ref;
+       zend_bool is_typed_ref = 0;
+
+       SAVE_OPLINE();
+
+       if (UNEXPECTED(zend_fetch_static_property_address(&prop, &prop_info, (opline+1)->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
+               ZEND_ASSERT(EG(exception));
+               UNDEF_RESULT();
+               FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
+               HANDLE_EXCEPTION();
+       }
+
+       value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data);
+
+       if (UNEXPECTED(Z_ISREF_P(prop))) {
+               ref = Z_REF_P(prop);
+               is_typed_ref = ZEND_REF_HAS_TYPE_SOURCES(ref);
+               prop = Z_REFVAL_P(prop);
+       }
+
+       if (UNEXPECTED(prop_info->type || is_typed_ref)) {
+               /* special case for typed properties */
+               zval z_copy;
+
+               binary_op(&z_copy, prop, value);
+               if (EXPECTED(is_typed_ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(prop);
+                       ZVAL_COPY_VALUE(prop, &z_copy);
+               } else {
+                       zval_ptr_dtor(&z_copy);
+               }
+       } else {
+               binary_op(prop, prop, value);
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+       }
+
+       FREE_OP(free_op_data);
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_CV_TMPVAR(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
@@ -42619,12 +48912,32 @@ assign_dim_op_new_array:
                        if (UNEXPECTED(!var_ptr)) {
                                goto assign_dim_op_ret_null;
                        }
-                       ZVAL_DEREF(var_ptr);
                }
 
                value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
-               binary_op(var_ptr, var_ptr, value);
+               if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
+                       zend_reference *ref = Z_REF_P(var_ptr);
+                       var_ptr = Z_REFVAL_P(var_ptr);
+                       if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                               zval tmp;
+                               binary_op(&tmp, var_ptr, value);
+                               if (EXPECTED(zend_verify_ref_assignable_zval(ref, &tmp, EX_USES_STRICT_TYPES()))) {
+                                       zval_ptr_dtor(var_ptr);
+                                       ZVAL_COPY_VALUE(var_ptr, &tmp);
+                               } else {
+                                       zval_ptr_dtor(&tmp);
+                                       zval_ptr_dtor_nogc(free_op2);
+                                       FREE_OP(free_op_data1);
+
+                                       HANDLE_EXCEPTION();
+                               }
+                       } else {
+                               binary_op(var_ptr, var_ptr, value);
+                       }
+               } else {
+                       binary_op(var_ptr, var_ptr, value);
+               }
 
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -42696,9 +49009,25 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_simple_helper
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               ZVAL_DEREF(var_ptr);
+               zend_reference *ref = NULL;
+               if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+                       ref = Z_REF_P(var_ptr);
+                       var_ptr = Z_REFVAL_P(var_ptr);
+               }
 
-               binary_op(var_ptr, var_ptr, value);
+               if (UNEXPECTED(ref && ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                       zval tmp;
+                       binary_op(&tmp, var_ptr, value);
+
+                       if (UNEXPECTED(zend_verify_ref_assignable_zval(ref, &tmp, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(var_ptr);
+                               ZVAL_COPY_VALUE(var_ptr, &tmp);
+                       } else {
+                               zval_ptr_dtor(&tmp);
+                       }
+               } else {
+                       binary_op(var_ptr, var_ptr, value);
+               }
 
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -42712,8 +49041,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_simple_helper
 
 static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_CV_TMPVAR(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
-#if 1 && (IS_TMP_VAR|IS_VAR) == IS_UNUSED
-       ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#if 1 && (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && ((IS_TMP_VAR|IS_VAR) == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 #else
 # if 0 || IS_CV != IS_UNUSED
 #  if 0
@@ -42727,6 +49062,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
        if (EXPECTED(0)) {
                ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
        }
+#  if 0 || (IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
 # endif
 
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -42735,8 +49075,14 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
 
 static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_CV_TMPVAR_DIM(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
-#if 1 && (IS_TMP_VAR|IS_VAR) == IS_UNUSED
-       ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#if 1 && (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && ((IS_TMP_VAR|IS_VAR) == IS_UNUSED)
+       if (EXPECTED(1)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 #else
 # if 0 || IS_CV != IS_UNUSED
 #  if 0
@@ -42750,6 +49096,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
        if (EXPECTED(1)) {
                ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
        }
+#  if 0 || (IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
 # endif
 
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -42758,8 +49109,48 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
 
 static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_CV_TMPVAR_OBJ(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
-#if 1 && (IS_TMP_VAR|IS_VAR) == IS_UNUSED
-       ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#if 1 && (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && ((IS_TMP_VAR|IS_VAR) == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#else
+# if 0 || IS_CV != IS_UNUSED
+#  if 0
+       /* opline->extended_value checks are specialized, don't need opline */
+       USE_OPLINE
+#  endif
+
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_simple_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  if 0 || (IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
+# endif
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#endif
+}
+
+static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_CV_TMPVAR_STATIC_PROP(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+#if 1 && (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && ((IS_TMP_VAR|IS_VAR) == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 #else
 # if 0 || IS_CV != IS_UNUSED
 #  if 0
@@ -42773,6 +49164,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
        if (EXPECTED(0)) {
                ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
        }
+#  if 0 || (IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(1)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
 # endif
 
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_CV_TMPVAR(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -42794,6 +49190,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_OBJ_
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR_OBJ(add_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR_STATIC_PROP(add_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR(sub_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -42809,6 +49210,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_OBJ_
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR_OBJ(sub_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR_STATIC_PROP(sub_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR(mul_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -42824,6 +49230,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_OBJ_
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR_OBJ(mul_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR_STATIC_PROP(mul_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR(div_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -42839,6 +49250,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_OBJ_
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR_OBJ(div_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR_STATIC_PROP(div_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR(mod_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -42854,6 +49270,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_OBJ_
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR_OBJ(mod_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR_STATIC_PROP(mod_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR(shift_left_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -42869,6 +49290,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_OBJ_H
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR_OBJ(shift_left_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR_STATIC_PROP(shift_left_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR(shift_right_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -42884,6 +49310,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_OBJ_H
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR_OBJ(shift_right_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR_STATIC_PROP(shift_right_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR(concat_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -42899,6 +49330,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_O
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR_OBJ(concat_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR_STATIC_PROP(concat_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR(bitwise_or_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -42914,6 +49350,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_OB
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR_OBJ(bitwise_or_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR_STATIC_PROP(bitwise_or_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR(bitwise_and_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -42929,6 +49370,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_O
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR_OBJ(bitwise_and_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR_STATIC_PROP(bitwise_and_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR(bitwise_xor_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -42944,6 +49390,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_O
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR_OBJ(bitwise_xor_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR_STATIC_PROP(bitwise_xor_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR(pow_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -42959,6 +49410,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ_
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR_OBJ(pow_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_TMPVAR_STATIC_PROP(pow_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_TMPVAR(int inc ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
@@ -42966,6 +49422,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
        zval *object;
        zval *property;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
@@ -42978,46 +49436,34 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
 
        do {
                if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto pre_incdec_object;
-                               }
+                               goto pre_incdec_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 pre_incdec_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        } else {
-                               if (EXPECTED(Z_TYPE_P(zptr) == IS_LONG)) {
-                                       if (inc) {
-                                               fast_long_increment_function(zptr);
-                                       } else {
-                                               fast_long_decrement_function(zptr);
-                                       }
+                               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
                                } else {
-                                       ZVAL_DEREF(zptr);
-
-                                       if (inc) {
-                                               increment_function(zptr);
-                                       } else {
-                                               decrement_function(zptr);
-                                       }
-                               }
-                               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                                       ZVAL_COPY(EX_VAR(opline->result.var), zptr);
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
                                }
+                               zend_pre_incdec_property_zval(zptr, prop_info, inc OPLINE_CC EXECUTE_DATA_CC);
                        }
                } else {
-                       zend_pre_incdec_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc OPLINE_CC EXECUTE_DATA_CC);
+                       zend_pre_incdec_overloaded_property(object, property, cache_slot, inc OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
@@ -43043,6 +49489,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
        zval *object;
        zval *property;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
@@ -43055,42 +49503,33 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
 
        do {
                if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto post_incdec_object;
-                               }
+                               goto post_incdec_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 post_incdec_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
                        } else {
-                               if (EXPECTED(Z_TYPE_P(zptr) == IS_LONG)) {
-                                       ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(zptr));
-                                       if (inc) {
-                                               fast_long_increment_function(zptr);
-                                       } else {
-                                               fast_long_decrement_function(zptr);
-                                       }
+                               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                                       prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
                                } else {
-                                       ZVAL_DEREF(zptr);
-                                       ZVAL_COPY(EX_VAR(opline->result.var), zptr);
-                                       if (inc) {
-                                               increment_function(zptr);
-                                       } else {
-                                               decrement_function(zptr);
-                                       }
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
                                }
+
+                               zend_post_incdec_property_zval(zptr, prop_info, inc OPLINE_CC EXECUTE_DATA_CC);
                        }
                } else {
-                       zend_post_incdec_overloaded_property(object, property, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc OPLINE_CC EXECUTE_DATA_CC);
+                       zend_post_incdec_overloaded_property(object, property, cache_slot, inc OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
@@ -43270,7 +49709,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HAN
                zval *retval;
 
                if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
-                       cache_slot = CACHE_ADDR(opline->extended_value);
+                       cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
                                uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
@@ -43341,7 +49780,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HAN
 
        property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_W OPLINE_CC);
+       zend_fetch_property_address(
+               result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR),
+               (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
+               BP_VAR_W, opline->extended_value & ZEND_FETCH_OBJ_FLAGS, 1 OPLINE_CC);
        zval_ptr_dtor_nogc(free_op2);
        if (IS_CV == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -43363,7 +49805,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HA
        }
        property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW OPLINE_CC);
+       zend_fetch_property_address(result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, 1 OPLINE_CC);
        zval_ptr_dtor_nogc(free_op2);
        if (IS_CV == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -43468,7 +49910,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP
                if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
                        ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
                }
-
                ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
                ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -43490,7 +49931,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR
 
        property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET OPLINE_CC);
+       zend_fetch_property_address(result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, 1 OPLINE_CC);
        zval_ptr_dtor_nogc(free_op2);
        if (IS_CV == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -43515,13 +49956,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
 
        if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
 
                        goto exit_assign_obj;
                }
@@ -43530,15 +49970,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D
 assign_object:
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_CONST & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_CONST & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+                                               zval_ptr_dtor_nogc(free_op2);
+
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_CONST == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_CONST & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_CONST);
+                                       value = zend_assign_to_variable(property_val, value, IS_CONST, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -43600,10 +50079,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
 
 exit_assign_obj:
@@ -43630,13 +50109,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D
        value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
                        zval_ptr_dtor_nogc(free_op_data);
                        goto exit_assign_obj;
                }
@@ -43645,15 +50123,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D
 assign_object:
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_TMP_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_TMP_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+                                               zval_ptr_dtor_nogc(free_op2);
+
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_TMP_VAR == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_TMP_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_TMP_VAR);
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -43715,10 +50232,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
        zval_ptr_dtor_nogc(free_op_data);
 exit_assign_obj:
@@ -43745,13 +50262,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D
        value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
 
        if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
                        zval_ptr_dtor_nogc(free_op_data);
                        goto exit_assign_obj;
                }
@@ -43760,15 +50276,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D
 assign_object:
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+                                               zval_ptr_dtor_nogc(free_op2);
+
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_VAR == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_VAR);
+                                       value = zend_assign_to_variable(property_val, value, IS_VAR, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -43830,10 +50385,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
        zval_ptr_dtor_nogc(free_op_data);
 exit_assign_obj:
@@ -43860,13 +50415,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D
        value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
 
                        goto exit_assign_obj;
                }
@@ -43875,15 +50429,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D
 assign_object:
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_CV & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_CV & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+                                               zval_ptr_dtor_nogc(free_op2);
+
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_CV == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_CV & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_CV);
+                                       value = zend_assign_to_variable(property_val, value, IS_CV, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -43945,10 +50538,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
 
 exit_assign_obj:
@@ -43962,14 +50555,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D
 {
        USE_OPLINE
 
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op2, free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = EX_VAR(opline->op1.var);
+       orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -44011,7 +50604,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = RT_CONSTANT((opline+1), (opline+1)->op1);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -44046,6 +50639,15 @@ try_assign_dim_array:
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+                               zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
+
+
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -44072,14 +50674,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D
 {
        USE_OPLINE
 
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op2, free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = EX_VAR(opline->op1.var);
+       orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -44121,7 +50723,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -44157,6 +50759,15 @@ try_assign_dim_array:
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+                               zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
+                               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -44183,14 +50794,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D
 {
        USE_OPLINE
 
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op2, free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = EX_VAR(opline->op1.var);
+       orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -44232,7 +50843,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -44268,6 +50879,15 @@ try_assign_dim_array:
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+                               zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
+                               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -44294,14 +50914,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_D
 {
        USE_OPLINE
 
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op2, free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = EX_VAR(opline->op1.var);
+       orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -44343,7 +50963,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_CV);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -44378,6 +50998,15 @@ try_assign_dim_array:
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+                               zval_ptr_dtor_nogc(EX_VAR(opline->op2.var));
+
+
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -44400,6 +51029,192 @@ assign_dim_error:
        ZEND_VM_NEXT_OPCODE_EX(1, 2);
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op2, free_op_data;
+       zval *property;
+       zval *container;
+       zval variable, *variable_ptr = &variable;
+       zval *value_ptr;
+       void **cache_addr;
+
+       SAVE_OPLINE();
+
+       container = EX_VAR(opline->op1.var);
+
+       if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
+               ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       }
+
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+
+       cache_addr = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
+
+       zend_fetch_property_address(variable_ptr, container, IS_CV, property, (IS_TMP_VAR|IS_VAR), cache_addr, BP_VAR_W, 0, 0 OPLINE_CC);
+       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
+               variable_ptr = Z_INDIRECT_P(variable_ptr);
+       }
+
+       value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (UNEXPECTED(Z_TYPE(variable) != IS_INDIRECT)) {
+               zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
+
+               zval_ptr_dtor_nogc(free_op2);
+               if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (IS_VAR == IS_VAR &&
+                  opline->extended_value == ZEND_RETURNS_FUNCTION &&
+                          UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
+                               Z_INDIRECT_P(variable_ptr), value_ptr, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC))) {
+
+                       zval_ptr_dtor_nogc(free_op2);
+                       if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+
+               zval_ptr_dtor_nogc(free_op2);
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               zend_property_info *prop_info = NULL;
+
+               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
+               } else {
+                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
+               }
+
+               if (UNEXPECTED(prop_info)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+
+                               zval_ptr_dtor_nogc(free_op2);
+                               if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+                               HANDLE_EXCEPTION();
+                       }
+
+                       if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr)) && Z_ISREF_P(variable_ptr)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+                       }
+               }
+               zend_assign_to_variable_reference(variable_ptr, value_ptr);
+               if (prop_info) {
+                       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               }
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+       }
+
+       zval_ptr_dtor_nogc(free_op2);
+       if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op2;
+       zval *property;
+       zval *container;
+       zval variable, *variable_ptr = &variable;
+       zval *value_ptr;
+       void **cache_addr;
+
+       SAVE_OPLINE();
+
+       container = EX_VAR(opline->op1.var);
+
+       if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
+               ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       }
+
+       property = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+
+       cache_addr = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
+
+       zend_fetch_property_address(variable_ptr, container, IS_CV, property, (IS_TMP_VAR|IS_VAR), cache_addr, BP_VAR_W, 0, 0 OPLINE_CC);
+       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
+               variable_ptr = Z_INDIRECT_P(variable_ptr);
+       }
+
+       value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (UNEXPECTED(Z_TYPE(variable) != IS_INDIRECT)) {
+               zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
+
+               zval_ptr_dtor_nogc(free_op2);
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (IS_CV == IS_VAR &&
+                  opline->extended_value == ZEND_RETURNS_FUNCTION &&
+                          UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
+                               Z_INDIRECT_P(variable_ptr), value_ptr, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC))) {
+
+                       zval_ptr_dtor_nogc(free_op2);
+
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+
+               zval_ptr_dtor_nogc(free_op2);
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               zend_property_info *prop_info = NULL;
+
+               if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
+               } else {
+                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
+               }
+
+               if (UNEXPECTED(prop_info)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+
+                               zval_ptr_dtor_nogc(free_op2);
+
+                               HANDLE_EXCEPTION();
+                       }
+
+                       if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr)) && Z_ISREF_P(variable_ptr)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+                       }
+               }
+               zend_assign_to_variable_reference(variable_ptr, value_ptr);
+               if (prop_info) {
+                       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               }
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+       }
+
+       zval_ptr_dtor_nogc(free_op2);
+
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -45092,7 +51907,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUS
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
+               value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
                if (UNEXPECTED(0)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -45120,7 +51935,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
+               value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
                if (UNEXPECTED(1)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -45304,94 +52119,83 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_H
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_CV_VAR(int type ZEND_OPCODE_HANDLER_ARGS_DC)
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_static_property_helper_SPEC_CV_VAR(int inc ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
-
-       zval *varname;
-       zval *retval;
-       zend_string *name, *tmp_name;
-       zend_class_entry *ce;
+       zval *prop;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
 
-       do {
-               if (IS_VAR == IS_CONST) {
-                       if (IS_CV == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value)) != NULL)) {
-                               retval = CACHED_PTR(opline->extended_value + sizeof(void*));
-                               break;
-                       } else {
-                               zval *class_name = RT_CONSTANT(opline, opline->op2);
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
 
-                               if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value)) == NULL)) {
-                                       ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
-                                       if (UNEXPECTED(ce == NULL)) {
+       zend_pre_incdec_property_zval(prop, prop_info->type ? prop_info : NULL, inc OPLINE_CC EXECUTE_DATA_CC);
 
-                                               retval = NULL;
-                                               break;
-                                       }
-                                       if (IS_CV != IS_CONST) {
-                                               CACHE_PTR(opline->extended_value, ce);
-                                       }
-                               }
-                       }
-               } else {
-                       if (IS_VAR == IS_UNUSED) {
-                               ce = zend_fetch_class(NULL, opline->op2.num);
-                               if (UNEXPECTED(ce == NULL)) {
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
 
-                                       retval = NULL;
-                                       break;
-                               }
-                       } else {
-                               ce = Z_CE_P(EX_VAR(opline->op2.var));
-                       }
-                       if (IS_CV == IS_CONST &&
-                           EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
-                               retval = CACHED_PTR(opline->extended_value + sizeof(void*));
-                               break;
-                       }
-               }
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_STATIC_PROP_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_pre_incdec_static_property_helper_SPEC_CV_VAR(1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
 
-               varname = EX_VAR(opline->op1.var);
-               if (IS_CV == IS_CONST) {
-                       name = Z_STR_P(varname);
-               } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
-                       name = Z_STR_P(varname);
-                       tmp_name = NULL;
-               } else {
-                       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
-                               zval_undefined_cv(EX(opline)->op1.var EXECUTE_DATA_CC);
-                       }
-                       name = zval_get_tmp_string(varname, &tmp_name);
-               }
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_pre_incdec_static_property_helper_SPEC_CV_VAR(0 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_static_property_helper_SPEC_CV_VAR(int inc ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       USE_OPLINE
+       zval *prop;
+       zend_property_info *prop_info;
 
-               retval = zend_std_get_static_property(ce, name, type == BP_VAR_IS);
+       SAVE_OPLINE();
 
-               if (IS_CV != IS_CONST) {
-                       zend_tmp_string_release(tmp_name);
-               }
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
 
-               if (IS_CV == IS_CONST && EXPECTED(retval)) {
-                       CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, retval);
-               }
+       zend_post_incdec_property_zval(prop, prop_info->type ? prop_info : NULL, inc OPLINE_CC EXECUTE_DATA_CC);
 
-       } while (0);
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_STATIC_PROP_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_post_incdec_static_property_helper_SPEC_CV_VAR(1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_STATIC_PROP_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_post_incdec_static_property_helper_SPEC_CV_VAR(0 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_CV_VAR(int type ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       USE_OPLINE
+       zval *prop;
 
-       if (UNEXPECTED(retval == NULL)) {
+       SAVE_OPLINE();
+
+       if (UNEXPECTED(zend_fetch_static_property_address(&prop, NULL, opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS, type, opline->extended_value & ZEND_FETCH_OBJ_FLAGS OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
                if (EG(exception)) {
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                } else {
                        ZEND_ASSERT(type == BP_VAR_IS);
-                       retval = &EG(uninitialized_zval);
+                       prop = &EG(uninitialized_zval);
                }
        }
 
        if (type == BP_VAR_R || type == BP_VAR_IS) {
-               ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
+               ZVAL_COPY_DEREF(EX_VAR(opline->result.var), prop);
        } else {
-               ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
+               ZVAL_INDIRECT(EX_VAR(opline->result.var), prop);
        }
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -45429,6 +52233,230 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_V
        ZEND_VM_TAIL_CALL(zend_fetch_static_prop_helper_SPEC_CV_VAR(BP_VAR_IS ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_CONST & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_CONST & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_CONST & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_CONST, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_TMP_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_TMP_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_TMP_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_VAR, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_CV & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_CV & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_CV & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_CV, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -45446,7 +52474,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUS
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
+               value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
                if (UNEXPECTED(0)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -45474,7 +52502,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
+               value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
                if (UNEXPECTED(1)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -45501,7 +52529,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER
        } else if (IS_CV == IS_VAR &&
                   UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
 
-               zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
+               zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
 
                if (UNEXPECTED(free_op2)) {zval_ptr_dtor_nogc(free_op2);};
                UNDEF_RESULT();
@@ -45534,6 +52562,58 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value_ptr;
+       zend_property_info *prop_info;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value & ~ZEND_RETURNS_FUNCTION, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value_ptr = get_zval_ptr_ptr((opline+1)->op1_type, (opline+1)->op1, &free_op_data, BP_VAR_W);
+
+       if ((opline+1)->op1_type == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               prop = &EG(uninitialized_zval);
+       } else if ((opline+1)->op1_type == IS_VAR && (opline->extended_value & ZEND_RETURNS_FUNCTION) && UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(prop, value_ptr, IS_VAR OPLINE_CC EXECUTE_DATA_CC))) {
+                       if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               if (UNEXPECTED(prop_info->type)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+                               if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+                               HANDLE_EXCEPTION();
+                       }
+                       if (UNEXPECTED(Z_REFCOUNTED_P(prop)) && Z_ISREF_P(prop)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(prop), prop_info);
+                       }
+               }
+       }
+       zend_assign_to_variable_reference(prop, value_ptr);
+       if (prop_info->type) {
+               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(prop), prop_info);
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+       }
+
+       if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_STATIC_PROP_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -45594,69 +52674,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC
        zval *value;
        int result;
 
-       zval *varname;
-       zend_string *name, *tmp_name;
-       zend_class_entry *ce;
-
        SAVE_OPLINE();
-       if (IS_VAR == IS_CONST) {
-               if (IS_CV == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY)) != NULL)) {
-                       value = CACHED_PTR((opline->extended_value & ~ZEND_ISEMPTY) + sizeof(void*));
-                       goto is_static_prop_return;
-               } else if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY)) == NULL)) {
-                       ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
-                       if (UNEXPECTED(ce == NULL)) {
-                               ZEND_ASSERT(EG(exception));
-                               ZVAL_UNDEF(EX_VAR(opline->result.var));
-                               HANDLE_EXCEPTION();
-                       }
-                       if (IS_CV != IS_CONST) {
-                               CACHE_PTR(opline->extended_value & ~ZEND_ISEMPTY, ce);
-                       }
-               }
-       } else {
-               if (IS_VAR == IS_UNUSED) {
-                       ce = zend_fetch_class(NULL, opline->op2.num);
-                       if (UNEXPECTED(ce == NULL)) {
-                               ZEND_ASSERT(EG(exception));
-
-                               ZVAL_UNDEF(EX_VAR(opline->result.var));
-                               HANDLE_EXCEPTION();
-                       }
-               } else {
-                       ce = Z_CE_P(EX_VAR(opline->op2.var));
-               }
-               if (IS_CV == IS_CONST &&
-                   EXPECTED(CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY) == ce)) {
-
-                       value = CACHED_PTR((opline->extended_value & ~ZEND_ISEMPTY) + sizeof(void*));
-                       goto is_static_prop_return;
-               }
-       }
-
-       varname = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
-       if (IS_CV == IS_CONST) {
-               name = Z_STR_P(varname);
-       } else {
-               name = zval_get_tmp_string(varname, &tmp_name);
-       }
 
-       value = zend_std_get_static_property(ce, name, 1);
+       result = zend_fetch_static_property_address(&value, NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0 OPLINE_CC EXECUTE_DATA_CC);
 
-       if (IS_CV == IS_CONST && value) {
-               CACHE_POLYMORPHIC_PTR(opline->extended_value & ~ZEND_ISEMPTY, ce, value);
-       }
-
-       if (IS_CV != IS_CONST) {
-               zend_tmp_string_release(tmp_name);
-       }
-
-is_static_prop_return:
        if (!(opline->extended_value & ZEND_ISEMPTY)) {
-               result = value && Z_TYPE_P(value) > IS_NULL &&
+               result = result == SUCCESS && Z_TYPE_P(value) > IS_NULL &&
                    (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
        } else {
-               result = !value || !i_zend_is_true(value);
+               result = result != SUCCESS || !i_zend_is_true(value);
        }
 
        ZEND_VM_SMART_BRANCH(result, 1);
@@ -45850,6 +52876,58 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND
        ZEND_VM_RETURN();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_static_prop_helper_SPEC_CV_UNUSED(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       /* This helper actually never will receive IS_VAR as second op, and has the same handling for VAR and TMP in the first op, but for interoperability with the other binary_assign_op helpers, it is necessary to "include" it */
+
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zend_reference *ref;
+       zend_bool is_typed_ref = 0;
+
+       SAVE_OPLINE();
+
+       if (UNEXPECTED(zend_fetch_static_property_address(&prop, &prop_info, (opline+1)->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
+               ZEND_ASSERT(EG(exception));
+               UNDEF_RESULT();
+               FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
+               HANDLE_EXCEPTION();
+       }
+
+       value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data);
+
+       if (UNEXPECTED(Z_ISREF_P(prop))) {
+               ref = Z_REF_P(prop);
+               is_typed_ref = ZEND_REF_HAS_TYPE_SOURCES(ref);
+               prop = Z_REFVAL_P(prop);
+       }
+
+       if (UNEXPECTED(prop_info->type || is_typed_ref)) {
+               /* special case for typed properties */
+               zval z_copy;
+
+               binary_op(&z_copy, prop, value);
+               if (EXPECTED(is_typed_ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(prop);
+                       ZVAL_COPY_VALUE(prop, &z_copy);
+               } else {
+                       zval_ptr_dtor(&z_copy);
+               }
+       } else {
+               binary_op(prop, prop, value);
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+       }
+
+       FREE_OP(free_op_data);
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
@@ -45880,12 +52958,32 @@ assign_dim_op_new_array:
                        if (UNEXPECTED(!var_ptr)) {
                                goto assign_dim_op_ret_null;
                        }
-                       ZVAL_DEREF(var_ptr);
                }
 
                value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
-               binary_op(var_ptr, var_ptr, value);
+               if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
+                       zend_reference *ref = Z_REF_P(var_ptr);
+                       var_ptr = Z_REFVAL_P(var_ptr);
+                       if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                               zval tmp;
+                               binary_op(&tmp, var_ptr, value);
+                               if (EXPECTED(zend_verify_ref_assignable_zval(ref, &tmp, EX_USES_STRICT_TYPES()))) {
+                                       zval_ptr_dtor(var_ptr);
+                                       ZVAL_COPY_VALUE(var_ptr, &tmp);
+                               } else {
+                                       zval_ptr_dtor(&tmp);
+
+                                       FREE_OP(free_op_data1);
+
+                                       HANDLE_EXCEPTION();
+                               }
+                       } else {
+                               binary_op(var_ptr, var_ptr, value);
+                       }
+               } else {
+                       binary_op(var_ptr, var_ptr, value);
+               }
 
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -45942,8 +53040,14 @@ assign_dim_op_ret_null:
 
 static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_CV_UNUSED_DIM(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
-#if 1 && IS_UNUSED == IS_UNUSED
-       ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#if 1 && (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && (IS_UNUSED == IS_UNUSED)
+       if (EXPECTED(1)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 #else
 # if 0 || IS_CV != IS_UNUSED
 #  if 0
@@ -45957,6 +53061,45 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
        if (EXPECTED(1)) {
                ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
        }
+#  if 0 || IS_UNUSED == IS_CONST || IS_UNUSED == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
+# endif
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#endif
+}
+
+static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_CV_UNUSED_STATIC_PROP(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+#if 1 && (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && (IS_UNUSED == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#else
+# if 0 || IS_CV != IS_UNUSED
+#  if 0
+       /* opline->extended_value checks are specialized, don't need opline */
+       USE_OPLINE
+#  endif
+
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_simple_helper_SPEC_CV_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  if 0 || IS_UNUSED == IS_CONST || IS_UNUSED == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(1)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
 # endif
 
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -45968,61 +53111,177 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_DIM_
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_UNUSED_DIM(add_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_UNUSED_STATIC_PROP(add_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_UNUSED_DIM(sub_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_UNUSED_STATIC_PROP(sub_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_UNUSED_DIM(mul_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_UNUSED_STATIC_PROP(mul_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_UNUSED_DIM(div_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_UNUSED_STATIC_PROP(div_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_UNUSED_DIM(mod_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_UNUSED_STATIC_PROP(mod_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_UNUSED_DIM(shift_left_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_UNUSED_STATIC_PROP(shift_left_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_UNUSED_DIM(shift_right_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_UNUSED_STATIC_PROP(shift_right_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_UNUSED_DIM(concat_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_UNUSED_STATIC_PROP(concat_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_UNUSED_DIM(bitwise_or_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_UNUSED_STATIC_PROP(bitwise_or_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_UNUSED_DIM(bitwise_and_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_UNUSED_STATIC_PROP(bitwise_and_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_UNUSED_DIM(bitwise_xor_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_UNUSED_STATIC_PROP(bitwise_xor_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_CV_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_UNUSED_DIM(pow_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_CV_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_helper_SPEC_CV_UNUSED_STATIC_PROP(pow_function ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_static_property_helper_SPEC_CV_UNUSED(int inc ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       USE_OPLINE
+       zval *prop;
+       zend_property_info *prop_info;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       zend_pre_incdec_property_zval(prop, prop_info->type ? prop_info : NULL, inc OPLINE_CC EXECUTE_DATA_CC);
+
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_STATIC_PROP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_pre_incdec_static_property_helper_SPEC_CV_UNUSED(1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_pre_incdec_static_property_helper_SPEC_CV_UNUSED(0 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_static_property_helper_SPEC_CV_UNUSED(int inc ZEND_OPCODE_HANDLER_ARGS_DC)
+{
+       USE_OPLINE
+       zval *prop;
+       zend_property_info *prop_info;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       zend_post_incdec_property_zval(prop, prop_info->type ? prop_info : NULL, inc OPLINE_CC EXECUTE_DATA_CC);
+
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_STATIC_PROP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_post_incdec_static_property_helper_SPEC_CV_UNUSED(1 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_STATIC_PROP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       ZEND_VM_TAIL_CALL(zend_post_incdec_static_property_helper_SPEC_CV_UNUSED(0 ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
@@ -46145,91 +53404,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLE
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_CV_UNUSED(int type ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
-
-       zval *varname;
-       zval *retval;
-       zend_string *name, *tmp_name;
-       zend_class_entry *ce;
+       zval *prop;
 
        SAVE_OPLINE();
 
-       do {
-               if (IS_UNUSED == IS_CONST) {
-                       if (IS_CV == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value)) != NULL)) {
-                               retval = CACHED_PTR(opline->extended_value + sizeof(void*));
-                               break;
-                       } else {
-                               zval *class_name = RT_CONSTANT(opline, opline->op2);
-
-                               if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value)) == NULL)) {
-                                       ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
-                                       if (UNEXPECTED(ce == NULL)) {
-
-                                               retval = NULL;
-                                               break;
-                                       }
-                                       if (IS_CV != IS_CONST) {
-                                               CACHE_PTR(opline->extended_value, ce);
-                                       }
-                               }
-                       }
-               } else {
-                       if (IS_UNUSED == IS_UNUSED) {
-                               ce = zend_fetch_class(NULL, opline->op2.num);
-                               if (UNEXPECTED(ce == NULL)) {
-
-                                       retval = NULL;
-                                       break;
-                               }
-                       } else {
-                               ce = Z_CE_P(EX_VAR(opline->op2.var));
-                       }
-                       if (IS_CV == IS_CONST &&
-                           EXPECTED(CACHED_PTR(opline->extended_value) == ce)) {
-                               retval = CACHED_PTR(opline->extended_value + sizeof(void*));
-                               break;
-                       }
-               }
-
-               varname = EX_VAR(opline->op1.var);
-               if (IS_CV == IS_CONST) {
-                       name = Z_STR_P(varname);
-               } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
-                       name = Z_STR_P(varname);
-                       tmp_name = NULL;
-               } else {
-                       if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
-                               zval_undefined_cv(EX(opline)->op1.var EXECUTE_DATA_CC);
-                       }
-                       name = zval_get_tmp_string(varname, &tmp_name);
-               }
-
-               retval = zend_std_get_static_property(ce, name, type == BP_VAR_IS);
-
-               if (IS_CV != IS_CONST) {
-                       zend_tmp_string_release(tmp_name);
-               }
-
-               if (IS_CV == IS_CONST && EXPECTED(retval)) {
-                       CACHE_POLYMORPHIC_PTR(opline->extended_value, ce, retval);
-               }
-
-       } while (0);
-
-       if (UNEXPECTED(retval == NULL)) {
+       if (UNEXPECTED(zend_fetch_static_property_address(&prop, NULL, opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS, type, opline->extended_value & ZEND_FETCH_OBJ_FLAGS OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
                if (EG(exception)) {
                        ZVAL_UNDEF(EX_VAR(opline->result.var));
                        HANDLE_EXCEPTION();
                } else {
                        ZEND_ASSERT(type == BP_VAR_IS);
-                       retval = &EG(uninitialized_zval);
+                       prop = &EG(uninitialized_zval);
                }
        }
 
        if (type == BP_VAR_R || type == BP_VAR_IS) {
-               ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
+               ZVAL_COPY_DEREF(EX_VAR(opline->result.var), prop);
        } else {
-               ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
+               ZVAL_INDIRECT(EX_VAR(opline->result.var), prop);
        }
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
@@ -46316,18 +53508,242 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNU
        }
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = RT_CONSTANT((opline+1), (opline+1)->op1);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_CONST & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_CONST & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_CONST & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_CONST, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_TMP_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_TMP_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_TMP_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_VAR, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *prop, *value;
+       zend_property_info *prop_info;
+       zval tmp;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(prop_info->type)) {
+               zend_reference *ref = NULL;
+               if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                       ref = Z_REF_P(value);
+                       value = Z_REFVAL_P(value);
+               }
+               if (((IS_CV & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                       ZVAL_COPY(&tmp, value);
+               } else {
+                       ZVAL_COPY_VALUE(&tmp, value);
+               }
+               if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                       zval_ptr_dtor(value);
+                       if ((IS_CV & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                               efree(ref);
+                       }
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               value = &tmp;
+               if ((IS_CV & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                       efree(ref);
+               }
+
+               value = zend_assign_to_variable(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+       } else {
+               value = zend_assign_to_variable(prop, value, IS_CV, EX_USES_STRICT_TYPES());
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), value);
+       }
+
+       /* assign_static_prop has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
 
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = EX_VAR(opline->op1.var);
+       orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -46369,7 +53785,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = RT_CONSTANT((opline+1), (opline+1)->op1);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -46404,6 +53820,15 @@ try_assign_dim_array:
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+
+
+
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -46430,14 +53855,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D
 {
        USE_OPLINE
 
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = EX_VAR(opline->op1.var);
+       orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -46479,7 +53904,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -46515,6 +53940,15 @@ try_assign_dim_array:
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+
+                               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -46541,14 +53975,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D
 {
        USE_OPLINE
 
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = EX_VAR(opline->op1.var);
+       orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -46590,7 +54024,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -46626,6 +54060,15 @@ try_assign_dim_array:
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+
+                               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -46652,14 +54095,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_D
 {
        USE_OPLINE
 
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = EX_VAR(opline->op1.var);
+       orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -46701,7 +54144,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_CV);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -46736,6 +54179,15 @@ try_assign_dim_array:
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+
+
+
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -46758,6 +54210,58 @@ assign_dim_error:
        ZEND_VM_NEXT_OPCODE_EX(1, 2);
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *prop, *value_ptr;
+       zend_property_info *prop_info;
+
+       SAVE_OPLINE();
+
+       if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value & ~ZEND_RETURNS_FUNCTION, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
+               FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       }
+
+       value_ptr = get_zval_ptr_ptr((opline+1)->op1_type, (opline+1)->op1, &free_op_data, BP_VAR_W);
+
+       if ((opline+1)->op1_type == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               prop = &EG(uninitialized_zval);
+       } else if ((opline+1)->op1_type == IS_VAR && (opline->extended_value & ZEND_RETURNS_FUNCTION) && UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(prop, value_ptr, IS_UNUSED OPLINE_CC EXECUTE_DATA_CC))) {
+                       if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               if (UNEXPECTED(prop_info->type)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+                               if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+                               HANDLE_EXCEPTION();
+                       }
+                       if (UNEXPECTED(Z_REFCOUNTED_P(prop)) && Z_ISREF_P(prop)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(prop), prop_info);
+                       }
+               }
+       }
+       zend_assign_to_variable_reference(prop, value_ptr);
+       if (prop_info->type) {
+               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(prop), prop_info);
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), prop);
+       }
+
+       if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);};
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -47133,69 +54637,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC
        zval *value;
        int result;
 
-       zval *varname;
-       zend_string *name, *tmp_name;
-       zend_class_entry *ce;
-
        SAVE_OPLINE();
-       if (IS_UNUSED == IS_CONST) {
-               if (IS_CV == IS_CONST && EXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY)) != NULL)) {
-                       value = CACHED_PTR((opline->extended_value & ~ZEND_ISEMPTY) + sizeof(void*));
-                       goto is_static_prop_return;
-               } else if (UNEXPECTED((ce = CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY)) == NULL)) {
-                       ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
-                       if (UNEXPECTED(ce == NULL)) {
-                               ZEND_ASSERT(EG(exception));
-                               ZVAL_UNDEF(EX_VAR(opline->result.var));
-                               HANDLE_EXCEPTION();
-                       }
-                       if (IS_CV != IS_CONST) {
-                               CACHE_PTR(opline->extended_value & ~ZEND_ISEMPTY, ce);
-                       }
-               }
-       } else {
-               if (IS_UNUSED == IS_UNUSED) {
-                       ce = zend_fetch_class(NULL, opline->op2.num);
-                       if (UNEXPECTED(ce == NULL)) {
-                               ZEND_ASSERT(EG(exception));
-
-                               ZVAL_UNDEF(EX_VAR(opline->result.var));
-                               HANDLE_EXCEPTION();
-                       }
-               } else {
-                       ce = Z_CE_P(EX_VAR(opline->op2.var));
-               }
-               if (IS_CV == IS_CONST &&
-                   EXPECTED(CACHED_PTR(opline->extended_value & ~ZEND_ISEMPTY) == ce)) {
-
-                       value = CACHED_PTR((opline->extended_value & ~ZEND_ISEMPTY) + sizeof(void*));
-                       goto is_static_prop_return;
-               }
-       }
-
-       varname = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
-       if (IS_CV == IS_CONST) {
-               name = Z_STR_P(varname);
-       } else {
-               name = zval_get_tmp_string(varname, &tmp_name);
-       }
 
-       value = zend_std_get_static_property(ce, name, 1);
+       result = zend_fetch_static_property_address(&value, NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0 OPLINE_CC EXECUTE_DATA_CC);
 
-       if (IS_CV == IS_CONST && value) {
-               CACHE_POLYMORPHIC_PTR(opline->extended_value & ~ZEND_ISEMPTY, ce, value);
-       }
-
-       if (IS_CV != IS_CONST) {
-               zend_tmp_string_release(tmp_name);
-       }
-
-is_static_prop_return:
        if (!(opline->extended_value & ZEND_ISEMPTY)) {
-               result = value && Z_TYPE_P(value) > IS_NULL &&
+               result = result == SUCCESS && Z_TYPE_P(value) > IS_NULL &&
                    (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL);
        } else {
-               result = !value || !i_zend_is_true(value);
+               result = result != SUCCESS || !i_zend_is_true(value);
        }
 
        ZEND_VM_SMART_BRANCH(result, 1);
@@ -47428,6 +54878,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_STATIC_SPEC_CV_UNUSED_HAN
                        GC_SET_REFCOUNT(ref, 2);
                        GC_TYPE_INFO(ref) = IS_REFERENCE;
                        ZVAL_COPY_VALUE(&ref->val, value);
+                       ref->sources.ptr = NULL;
                        Z_REF_P(value) = ref;
                        Z_TYPE_INFO_P(value) = IS_REFERENCE_EX;
                        ZVAL_REF(variable_ptr, ref);
@@ -48266,11 +55717,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZE
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CV(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
-       zend_free_op free_op_data1;
+       zend_free_op free_op_data;
        zval *object;
        zval *property;
        zval *value;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
@@ -48282,41 +55735,68 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_obj_helper_SP
        property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
 
        do {
-               value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
+               value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data);
 
                if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto assign_op_object;
-                               }
+                               goto assign_op_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 assign_op_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        } else {
-                               ZVAL_DEREF(zptr);
+                               zval *orig_zptr = zptr;
+                               zend_reference *ref;
+                               zend_bool is_typed_ref = 0;
+
+                               if (UNEXPECTED(Z_ISREF_P(zptr))) {
+                                       ref = Z_REF_P(zptr);
+                                       is_typed_ref = ZEND_REF_HAS_TYPE_SOURCES(ref);
+                                       zptr = Z_REFVAL_P(zptr);
+                               }
+
+                               if (IS_CV == IS_CONST) {
+                                       prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
+                               } else {
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
+                               }
+                               if (UNEXPECTED(prop_info || is_typed_ref)) {
+                                       /* special case for typed properties */
+                                       zval z_copy;
+
+                                       binary_op(&z_copy, zptr, value);
+                                       if (EXPECTED(is_typed_ref ? zend_verify_ref_assignable_zval(ref, &z_copy, EX_USES_STRICT_TYPES()) : zend_verify_property_type(prop_info, &z_copy, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(zptr);
+                                               ZVAL_COPY_VALUE(zptr, &z_copy);
+                                       } else {
+                                               zval_ptr_dtor(&z_copy);
+                                       }
+                               } else {
+                                       binary_op(zptr, zptr, value);
+                               }
 
-                               binary_op(zptr, zptr, value);
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), zptr);
                                }
                        }
                } else {
-                       zend_assign_op_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL), value, binary_op OPLINE_CC EXECUTE_DATA_CC);
+                       zend_assign_op_overloaded_property(object, property, cache_slot, value, binary_op OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
-       FREE_OP(free_op_data1);
+       FREE_OP(free_op_data);
 
 
        /* assign_obj has two opcodes! */
@@ -48353,12 +55833,32 @@ assign_dim_op_new_array:
                        if (UNEXPECTED(!var_ptr)) {
                                goto assign_dim_op_ret_null;
                        }
-                       ZVAL_DEREF(var_ptr);
                }
 
                value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1, &free_op_data1);
 
-               binary_op(var_ptr, var_ptr, value);
+               if (IS_CV != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
+                       zend_reference *ref = Z_REF_P(var_ptr);
+                       var_ptr = Z_REFVAL_P(var_ptr);
+                       if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                               zval tmp;
+                               binary_op(&tmp, var_ptr, value);
+                               if (EXPECTED(zend_verify_ref_assignable_zval(ref, &tmp, EX_USES_STRICT_TYPES()))) {
+                                       zval_ptr_dtor(var_ptr);
+                                       ZVAL_COPY_VALUE(var_ptr, &tmp);
+                               } else {
+                                       zval_ptr_dtor(&tmp);
+
+                                       FREE_OP(free_op_data1);
+
+                                       HANDLE_EXCEPTION();
+                               }
+                       } else {
+                               binary_op(var_ptr, var_ptr, value);
+                       }
+               } else {
+                       binary_op(var_ptr, var_ptr, value);
+               }
 
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -48429,9 +55929,25 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_simple_helper
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               ZVAL_DEREF(var_ptr);
+               zend_reference *ref = NULL;
+               if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
+                       ref = Z_REF_P(var_ptr);
+                       var_ptr = Z_REFVAL_P(var_ptr);
+               }
 
-               binary_op(var_ptr, var_ptr, value);
+               if (UNEXPECTED(ref && ZEND_REF_HAS_TYPE_SOURCES(ref))) {
+                       zval tmp;
+                       binary_op(&tmp, var_ptr, value);
+
+                       if (UNEXPECTED(zend_verify_ref_assignable_zval(ref, &tmp, EX_USES_STRICT_TYPES()))) {
+                               zval_ptr_dtor(var_ptr);
+                               ZVAL_COPY_VALUE(var_ptr, &tmp);
+                       } else {
+                               zval_ptr_dtor(&tmp);
+                       }
+               } else {
+                       binary_op(var_ptr, var_ptr, value);
+               }
 
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
@@ -48444,8 +55960,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_binary_assign_op_simple_helper
 
 static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_CV_CV(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
-#if 1 && IS_CV == IS_UNUSED
-       ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#if 1 && (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && (IS_CV == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 #else
 # if 0 || IS_CV != IS_UNUSED
 #  if 0
@@ -48459,6 +55981,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
        if (EXPECTED(0)) {
                ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
        }
+#  if 0 || IS_CV == IS_CONST || IS_CV == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
 # endif
 
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_CV_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -48467,8 +55994,14 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
 
 static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_CV_CV_DIM(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
-#if 1 && IS_CV == IS_UNUSED
-       ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#if 1 && (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && (IS_CV == IS_UNUSED)
+       if (EXPECTED(1)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 #else
 # if 0 || IS_CV != IS_UNUSED
 #  if 0
@@ -48482,6 +56015,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
        if (EXPECTED(1)) {
                ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
        }
+#  if 0 || IS_CV == IS_CONST || IS_CV == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
 # endif
 
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_CV_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -48490,8 +56028,14 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
 
 static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_SPEC_CV_CV_OBJ(binary_op_type binary_op ZEND_OPCODE_HANDLER_ARGS_DC)
 {
-#if 1 && IS_CV == IS_UNUSED
-       ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#if 1 && (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR)
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+#elif 1 && (IS_CV == IS_UNUSED)
+       if (EXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+
+       ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 #else
 # if 0 || IS_CV != IS_UNUSED
 #  if 0
@@ -48505,6 +56049,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_binary_assign_op_helper_S
        if (EXPECTED(0)) {
                ZEND_VM_TAIL_CALL(zend_binary_assign_op_dim_helper_SPEC_CV_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
        }
+#  if 0 || IS_CV == IS_CONST || IS_CV == (IS_TMP_VAR|IS_VAR)
+       if (UNEXPECTED(0)) {
+               ZEND_VM_TAIL_CALL(zend_binary_assign_op_static_prop_helper_SPEC_CV_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+       }
+#  endif
 # endif
 
        ZEND_VM_TAIL_CALL(zend_binary_assign_op_obj_helper_SPEC_CV_CV(binary_op ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
@@ -48698,6 +56247,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
        zval *object;
        zval *property;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
@@ -48710,46 +56261,34 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_pre_incdec_property_helper_SPE
 
        do {
                if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto pre_incdec_object;
-                               }
+                               goto pre_incdec_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 pre_incdec_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_NULL(EX_VAR(opline->result.var));
                                }
                        } else {
-                               if (EXPECTED(Z_TYPE_P(zptr) == IS_LONG)) {
-                                       if (inc) {
-                                               fast_long_increment_function(zptr);
-                                       } else {
-                                               fast_long_decrement_function(zptr);
-                                       }
+                               if (IS_CV == IS_CONST) {
+                                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
                                } else {
-                                       ZVAL_DEREF(zptr);
-
-                                       if (inc) {
-                                               increment_function(zptr);
-                                       } else {
-                                               decrement_function(zptr);
-                                       }
-                               }
-                               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                                       ZVAL_COPY(EX_VAR(opline->result.var), zptr);
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
                                }
+                               zend_pre_incdec_property_zval(zptr, prop_info, inc OPLINE_CC EXECUTE_DATA_CC);
                        }
                } else {
-                       zend_pre_incdec_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc OPLINE_CC EXECUTE_DATA_CC);
+                       zend_pre_incdec_overloaded_property(object, property, cache_slot, inc OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
@@ -48774,6 +56313,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
        zval *object;
        zval *property;
        zval *zptr;
+       void **cache_slot;
+       zend_property_info *prop_info;
 
        SAVE_OPLINE();
        object = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC);
@@ -48786,42 +56327,33 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_post_incdec_property_helper_SP
 
        do {
                if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-                       if (Z_ISREF_P(object)) {
+                       if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                                object = Z_REFVAL_P(object);
-                               if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                                       goto post_incdec_object;
-                               }
+                               goto post_incdec_object;
                        }
-                       if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+                       object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+                       if (UNEXPECTED(!object)) {
                                break;
                        }
                }
 
-               /* here we are sure we are dealing with an object */
 post_incdec_object:
-               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL))) != NULL)) {
+               /* here we are sure we are dealing with an object */
+               cache_slot = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
+               if (EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, cache_slot)) != NULL)) {
                        if (UNEXPECTED(Z_ISERROR_P(zptr))) {
                                ZVAL_NULL(EX_VAR(opline->result.var));
                        } else {
-                               if (EXPECTED(Z_TYPE_P(zptr) == IS_LONG)) {
-                                       ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(zptr));
-                                       if (inc) {
-                                               fast_long_increment_function(zptr);
-                                       } else {
-                                               fast_long_decrement_function(zptr);
-                                       }
+                               if (IS_CV == IS_CONST) {
+                                       prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
                                } else {
-                                       ZVAL_DEREF(zptr);
-                                       ZVAL_COPY(EX_VAR(opline->result.var), zptr);
-                                       if (inc) {
-                                               increment_function(zptr);
-                                       } else {
-                                               decrement_function(zptr);
-                                       }
+                                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
                                }
+
+                               zend_post_incdec_property_zval(zptr, prop_info, inc OPLINE_CC EXECUTE_DATA_CC);
                        }
                } else {
-                       zend_post_incdec_overloaded_property(object, property, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), inc OPLINE_CC EXECUTE_DATA_CC);
+                       zend_post_incdec_overloaded_property(object, property, cache_slot, inc OPLINE_CC EXECUTE_DATA_CC);
                }
        } while (0);
 
@@ -49000,7 +56532,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER
                zval *retval;
 
                if (IS_CV == IS_CONST) {
-                       cache_slot = CACHE_ADDR(opline->extended_value);
+                       cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */);
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
                                uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
@@ -49071,7 +56603,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER
 
        property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_W OPLINE_CC);
+       zend_fetch_property_address(
+               result, container, IS_CV, property, IS_CV,
+               ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL),
+               BP_VAR_W, opline->extended_value & ZEND_FETCH_OBJ_FLAGS, 1 OPLINE_CC);
 
        if (IS_CV == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -49093,7 +56628,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLE
        }
        property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW OPLINE_CC);
+       zend_fetch_property_address(result, container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, 1 OPLINE_CC);
 
        if (IS_CV == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -49198,7 +56733,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_
                if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
                        ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
                }
-
                ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
        } else {
                ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
@@ -49220,7 +56754,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HAN
 
        property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
        result = EX_VAR(opline->result.var);
-       zend_fetch_property_address(result, container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET OPLINE_CC);
+       zend_fetch_property_address(result, container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, 1 OPLINE_CC);
 
        if (IS_CV == IS_VAR) {
                FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(free_op1, result);
@@ -49245,13 +56779,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_
        value = RT_CONSTANT((opline+1), (opline+1)->op1);
 
        if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
 
                        goto exit_assign_obj;
                }
@@ -49260,245 +56793,360 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_
 assign_object:
        if (IS_CV == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
-fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_CONST);
-                               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-                               }
-                               goto exit_assign_obj;
-                       }
-               } else {
-                       if (EXPECTED(zobj->properties != NULL)) {
-                               if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
-                                       if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
-                                               GC_DELREF(zobj->properties);
-                                       }
-                                       zobj->properties = zend_array_dup(zobj->properties);
-                               }
-                               property_val = zend_hash_find_ex(zobj->properties, Z_STR_P(property), 1);
-                               if (property_val) {
-                                       goto fast_assign_obj;
-                               }
-                       }
-
-                       if (!zobj->ce->__set) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
 
-                               if (EXPECTED(zobj->properties == NULL)) {
-                                       rebuild_object_properties(zobj);
-                               }
-                               if (IS_CONST == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
-                                               Z_ADDREF_P(value);
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
                                        }
-                               } else if (IS_CONST != IS_TMP_VAR) {
-                                       if (Z_ISREF_P(value)) {
-                                               if (IS_CONST == IS_VAR) {
-                                                       zend_reference *ref = Z_REF_P(value);
-                                                       if (GC_DELREF(ref) == 0) {
-                                                               ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
-                                                               efree_size(ref, sizeof(zend_reference));
-                                                               value = &tmp;
-                                                       } else {
-                                                               value = Z_REFVAL_P(value);
-                                                               Z_TRY_ADDREF_P(value);
-                                                       }
-                                               } else {
-                                                       value = Z_REFVAL_P(value);
-                                                       Z_TRY_ADDREF_P(value);
-                                               }
-                                       } else if (IS_CONST == IS_CV) {
-                                               Z_TRY_ADDREF_P(value);
+                                       if (((IS_CONST & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
                                        }
-                               }
-                               zend_hash_add_new(zobj->properties, Z_STR_P(property), value);
-                               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-                               }
-                               goto exit_assign_obj;
-                       }
-               }
-       }
-
-       if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
-               ZVAL_DEREF(value);
-       }
-
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
-
-       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
-       }
-
-exit_assign_obj:
-
-
-       /* assign_obj has two opcodes! */
-       ZEND_VM_NEXT_OPCODE_EX(1, 2);
-}
-
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op_data;
-       zval *object, *property, *value, tmp;
-
-       SAVE_OPLINE();
-       object = EX_VAR(opline->op1.var);
-
-       if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
-               ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
-       }
-
-       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
-       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-
-       if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
-                       object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
-               }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
-                       zval_ptr_dtor_nogc(free_op_data);
-                       goto exit_assign_obj;
-               }
-       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_CONST & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
 
-assign_object:
-       if (IS_CV == IS_CONST &&
-           EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
-               zend_object *zobj = Z_OBJ_P(object);
-               zval *property_val;
 
-               if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
-                       property_val = OBJ_PROP(zobj, prop_offset);
-                       if (Z_TYPE_P(property_val) != IS_UNDEF) {
-fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_TMP_VAR);
-                               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-                               }
-                               goto exit_assign_obj;
-                       }
-               } else {
-                       if (EXPECTED(zobj->properties != NULL)) {
-                               if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
-                                       if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
-                                               GC_DELREF(zobj->properties);
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
                                        }
-                                       zobj->properties = zend_array_dup(zobj->properties);
-                               }
-                               property_val = zend_hash_find_ex(zobj->properties, Z_STR_P(property), 1);
-                               if (property_val) {
-                                       goto fast_assign_obj;
-                               }
-                       }
-
-                       if (!zobj->ce->__set) {
 
-                               if (EXPECTED(zobj->properties == NULL)) {
-                                       rebuild_object_properties(zobj);
-                               }
-                               if (IS_TMP_VAR == IS_CONST) {
-                                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
-                                               Z_ADDREF_P(value);
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_CONST == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
                                        }
-                               } else if (IS_TMP_VAR != IS_TMP_VAR) {
-                                       if (Z_ISREF_P(value)) {
-                                               if (IS_TMP_VAR == IS_VAR) {
-                                                       zend_reference *ref = Z_REF_P(value);
-                                                       if (GC_DELREF(ref) == 0) {
-                                                               ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
-                                                               efree_size(ref, sizeof(zend_reference));
-                                                               value = &tmp;
-                                                       } else {
-                                                               value = Z_REFVAL_P(value);
-                                                               Z_TRY_ADDREF_P(value);
-                                                       }
-                                               } else {
-                                                       value = Z_REFVAL_P(value);
-                                                       Z_TRY_ADDREF_P(value);
-                                               }
-                                       } else if (IS_TMP_VAR == IS_CV) {
-                                               Z_TRY_ADDREF_P(value);
-                                       }
-                               }
-                               zend_hash_add_new(zobj->properties, Z_STR_P(property), value);
-                               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-                                       ZVAL_COPY(EX_VAR(opline->result.var), value);
-                               }
-                               goto exit_assign_obj;
-                       }
-               }
-       }
 
-       if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
-               ZVAL_DEREF(value);
-       }
-
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
-
-       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
-       }
-       zval_ptr_dtor_nogc(free_op_data);
-exit_assign_obj:
-
-
-       /* assign_obj has two opcodes! */
-       ZEND_VM_NEXT_OPCODE_EX(1, 2);
-}
-
-static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op_data;
-       zval *object, *property, *value, tmp;
-
-       SAVE_OPLINE();
-       object = EX_VAR(opline->op1.var);
-
-       if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
-               ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
-       }
-
-       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
-       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-
-       if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
-                       object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
-               }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
-                       zval_ptr_dtor_nogc(free_op_data);
-                       goto exit_assign_obj;
-               }
-       }
-
-assign_object:
-       if (IS_CV == IS_CONST &&
-           EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
-               zend_object *zobj = Z_OBJ_P(object);
-               zval *property_val;
+                                       value = &tmp;
+                                       if ((IS_CONST & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
 
-               if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
-                       property_val = OBJ_PROP(zobj, prop_offset);
-                       if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_VAR);
+                                       value = zend_assign_to_variable(property_val, value, IS_CONST, EX_USES_STRICT_TYPES());
+                               }
+                               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+                                       ZVAL_COPY(EX_VAR(opline->result.var), value);
+                               }
+                               goto exit_assign_obj;
+                       }
+               } else {
+                       if (EXPECTED(zobj->properties != NULL)) {
+                               if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
+                                       if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
+                                               GC_DELREF(zobj->properties);
+                                       }
+                                       zobj->properties = zend_array_dup(zobj->properties);
+                               }
+                               property_val = zend_hash_find_ex(zobj->properties, Z_STR_P(property), 1);
+                               if (property_val) {
+                                       goto fast_assign_obj;
+                               }
+                       }
+
+                       if (!zobj->ce->__set) {
+
+                               if (EXPECTED(zobj->properties == NULL)) {
+                                       rebuild_object_properties(zobj);
+                               }
+                               if (IS_CONST == IS_CONST) {
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
+                                               Z_ADDREF_P(value);
+                                       }
+                               } else if (IS_CONST != IS_TMP_VAR) {
+                                       if (Z_ISREF_P(value)) {
+                                               if (IS_CONST == IS_VAR) {
+                                                       zend_reference *ref = Z_REF_P(value);
+                                                       if (GC_DELREF(ref) == 0) {
+                                                               ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
+                                                               efree_size(ref, sizeof(zend_reference));
+                                                               value = &tmp;
+                                                       } else {
+                                                               value = Z_REFVAL_P(value);
+                                                               Z_TRY_ADDREF_P(value);
+                                                       }
+                                               } else {
+                                                       value = Z_REFVAL_P(value);
+                                                       Z_TRY_ADDREF_P(value);
+                                               }
+                                       } else if (IS_CONST == IS_CV) {
+                                               Z_TRY_ADDREF_P(value);
+                                       }
+                               }
+                               zend_hash_add_new(zobj->properties, Z_STR_P(property), value);
+                               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+                                       ZVAL_COPY(EX_VAR(opline->result.var), value);
+                               }
+                               goto exit_assign_obj;
+                       }
+               }
+       }
+
+       if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
+               ZVAL_DEREF(value);
+       }
+
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
+       }
+
+exit_assign_obj:
+
+
+       /* assign_obj has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *object, *property, *value, tmp;
+
+       SAVE_OPLINE();
+       object = EX_VAR(opline->op1.var);
+
+       if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
+               ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       }
+
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+       value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
+                       object = Z_REFVAL_P(object);
+                       goto assign_object;
+               }
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
+                       zval_ptr_dtor_nogc(free_op_data);
+                       goto exit_assign_obj;
+               }
+       }
+
+assign_object:
+       if (IS_CV == IS_CONST &&
+           EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
+               zend_object *zobj = Z_OBJ_P(object);
+               zval *property_val;
+
+               if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
+                       property_val = OBJ_PROP(zobj, prop_offset);
+                       if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_TMP_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_TMP_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+
+
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_TMP_VAR == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_TMP_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
+fast_assign_obj:
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               }
+                               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+                                       ZVAL_COPY(EX_VAR(opline->result.var), value);
+                               }
+                               goto exit_assign_obj;
+                       }
+               } else {
+                       if (EXPECTED(zobj->properties != NULL)) {
+                               if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
+                                       if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
+                                               GC_DELREF(zobj->properties);
+                                       }
+                                       zobj->properties = zend_array_dup(zobj->properties);
+                               }
+                               property_val = zend_hash_find_ex(zobj->properties, Z_STR_P(property), 1);
+                               if (property_val) {
+                                       goto fast_assign_obj;
+                               }
+                       }
+
+                       if (!zobj->ce->__set) {
+
+                               if (EXPECTED(zobj->properties == NULL)) {
+                                       rebuild_object_properties(zobj);
+                               }
+                               if (IS_TMP_VAR == IS_CONST) {
+                                       if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) {
+                                               Z_ADDREF_P(value);
+                                       }
+                               } else if (IS_TMP_VAR != IS_TMP_VAR) {
+                                       if (Z_ISREF_P(value)) {
+                                               if (IS_TMP_VAR == IS_VAR) {
+                                                       zend_reference *ref = Z_REF_P(value);
+                                                       if (GC_DELREF(ref) == 0) {
+                                                               ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value));
+                                                               efree_size(ref, sizeof(zend_reference));
+                                                               value = &tmp;
+                                                       } else {
+                                                               value = Z_REFVAL_P(value);
+                                                               Z_TRY_ADDREF_P(value);
+                                                       }
+                                               } else {
+                                                       value = Z_REFVAL_P(value);
+                                                       Z_TRY_ADDREF_P(value);
+                                               }
+                                       } else if (IS_TMP_VAR == IS_CV) {
+                                               Z_TRY_ADDREF_P(value);
+                                       }
+                               }
+                               zend_hash_add_new(zobj->properties, Z_STR_P(property), value);
+                               if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+                                       ZVAL_COPY(EX_VAR(opline->result.var), value);
+                               }
+                               goto exit_assign_obj;
+                       }
+               }
+       }
+
+       if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
+               ZVAL_DEREF(value);
+       }
+
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
+       }
+       zval_ptr_dtor_nogc(free_op_data);
+exit_assign_obj:
+
+
+       /* assign_obj has two opcodes! */
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *object, *property, *value, tmp;
+
+       SAVE_OPLINE();
+       object = EX_VAR(opline->op1.var);
+
+       if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
+               ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       }
+
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+       value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
+                       object = Z_REFVAL_P(object);
+                       goto assign_object;
+               }
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
+                       zval_ptr_dtor_nogc(free_op_data);
+                       goto exit_assign_obj;
+               }
+       }
+
+assign_object:
+       if (IS_CV == IS_CONST &&
+           EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
+               zend_object *zobj = Z_OBJ_P(object);
+               zval *property_val;
+
+               if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
+                       property_val = OBJ_PROP(zobj, prop_offset);
+                       if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_VAR & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_VAR & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+
+
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_VAR == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_VAR & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
+fast_assign_obj:
+                                       value = zend_assign_to_variable(property_val, value, IS_VAR, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -49560,10 +57208,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
        zval_ptr_dtor_nogc(free_op_data);
 exit_assign_obj:
@@ -49590,13 +57238,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_
        value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
 
        if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
-               if (Z_ISREF_P(object)) {
+               if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
                        object = Z_REFVAL_P(object);
-                       if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) {
-                               goto assign_object;
-                       }
+                       goto assign_object;
                }
-               if (UNEXPECTED(!make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC))) {
+               object = make_real_object(object, property OPLINE_CC EXECUTE_DATA_CC);
+               if (UNEXPECTED(!object)) {
 
                        goto exit_assign_obj;
                }
@@ -49605,15 +57252,54 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_
 assign_object:
        if (IS_CV == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(opline->extended_value))) {
-               uintptr_t prop_offset = (uintptr_t)CACHED_PTR(opline->extended_value + sizeof(void*));
+               void **cache_slot = CACHE_ADDR(opline->extended_value);
+               uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                        property_val = OBJ_PROP(zobj, prop_offset);
                        if (Z_TYPE_P(property_val) != IS_UNDEF) {
+                               zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2);
+                               zval tmp;
+
+                               if (UNEXPECTED(prop_info != NULL)) {
+                                       zend_reference *ref = NULL;
+                                       if ((IS_CV & (IS_CV|IS_VAR)) && UNEXPECTED(Z_ISREF_P(value))) {
+                                               ref = Z_REF_P(value);
+                                               value = Z_REFVAL_P(value);
+                                       }
+                                       if (((IS_CV & (IS_CONST|IS_CV)) || (ref && GC_REFCOUNT(ref) > 1))) {
+                                               ZVAL_COPY(&tmp, value);
+                                       } else {
+                                               ZVAL_COPY_VALUE(&tmp, value);
+                                       }
+                                       if (UNEXPECTED(!i_zend_verify_property_type(prop_info, &tmp, EX_USES_STRICT_TYPES()))) {
+                                               zval_ptr_dtor(value);
+                                               if ((IS_CV & IS_VAR) && ref && GC_DELREF(ref) == 0) {
+                                                       efree(ref);
+                                               }
+
+
+                                               UNDEF_RESULT();
+                                               HANDLE_EXCEPTION();
+                                       }
+
+                                       /* will remain valid, thus no need to check prop_info in future here */
+                                       if (IS_CV == IS_CONST && Z_TYPE(tmp) == Z_TYPE_P(value)) {
+                                               CACHE_PTR_EX(cache_slot + 2, NULL);
+                                       }
+
+                                       value = &tmp;
+                                       if ((IS_CV & IS_VAR) && UNEXPECTED(ref) && GC_DELREF(ref) == 0) {
+                                               efree(ref);
+                                       }
+
+                                       value = zend_assign_to_variable(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
+                               } else {
 fast_assign_obj:
-                               value = zend_assign_to_variable(property_val, value, IS_CV);
+                                       value = zend_assign_to_variable(property_val, value, IS_CV, EX_USES_STRICT_TYPES());
+                               }
                                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                                }
@@ -49675,10 +57361,10 @@ fast_assign_obj:
                ZVAL_DEREF(value);
        }
 
-       Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
+       property = Z_OBJ_HT_P(object)->write_property(object, property, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL);
 
        if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
-               ZVAL_COPY(EX_VAR(opline->result.var), value);
+               ZVAL_COPY(EX_VAR(opline->result.var), property);
        }
 
 exit_assign_obj:
@@ -49692,14 +57378,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_
 {
        USE_OPLINE
 
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = EX_VAR(opline->op1.var);
+       orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -49741,7 +57427,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = RT_CONSTANT((opline+1), (opline+1)->op1);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_CONST);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -49776,6 +57462,15 @@ try_assign_dim_array:
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+
+
+
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -49802,14 +57497,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_
 {
        USE_OPLINE
 
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = EX_VAR(opline->op1.var);
+       orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -49851,7 +57546,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = _get_zval_ptr_tmp((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -49887,6 +57582,15 @@ try_assign_dim_array:
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+
+                               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -49913,14 +57617,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_
 {
        USE_OPLINE
 
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = EX_VAR(opline->op1.var);
+       orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -49962,7 +57666,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = _get_zval_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_VAR);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -49998,6 +57702,15 @@ try_assign_dim_array:
                                zval_ptr_dtor_nogc(free_op_data);
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+
+                               zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var));
+
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -50024,14 +57737,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_
 {
        USE_OPLINE
 
-       zval *object_ptr;
+       zval *object_ptr, *orig_object_ptr;
        zend_free_op free_op_data;
        zval *value;
        zval *variable_ptr;
        zval *dim;
 
        SAVE_OPLINE();
-       object_ptr = EX_VAR(opline->op1.var);
+       orig_object_ptr = object_ptr = EX_VAR(opline->op1.var);
 
        if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) {
 try_assign_dim_array:
@@ -50073,7 +57786,7 @@ try_assign_dim_array:
                                goto assign_dim_error;
                        }
                        value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC);
-                       value = zend_assign_to_variable(variable_ptr, value, IS_CV);
+                       value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
                }
                if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
@@ -50108,6 +57821,15 @@ try_assign_dim_array:
 
                        }
                } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) {
+                       zend_property_info *error_prop;
+                       if (Z_ISREF_P(orig_object_ptr) && (error_prop = zend_check_ref_array_assignable(Z_REF_P(orig_object_ptr))) != NULL) {
+                               zend_throw_auto_init_in_ref_error(error_prop, "array");
+
+
+
+                               UNDEF_RESULT();
+                               HANDLE_EXCEPTION();
+                       }
                        ZVAL_ARR(object_ptr, zend_new_array(8));
                        goto try_assign_dim_array;
                } else {
@@ -50147,7 +57869,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSE
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_CV);
+               value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
                if (UNEXPECTED(0)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -50175,7 +57897,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED_
                        ZVAL_NULL(EX_VAR(opline->result.var));
                }
        } else {
-               value = zend_assign_to_variable(variable_ptr, value, IS_CV);
+               value = zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES());
                if (UNEXPECTED(1)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), value);
                }
@@ -50202,7 +57924,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(
        } else if (IS_CV == IS_VAR &&
                   UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
 
-               zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
+               zend_throw_error(NULL, "Cannot assign by reference to an array dimension of an object");
 
 
                UNDEF_RESULT();
@@ -50234,6 +57956,192 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op_data;
+       zval *property;
+       zval *container;
+       zval variable, *variable_ptr = &variable;
+       zval *value_ptr;
+       void **cache_addr;
+
+       SAVE_OPLINE();
+
+       container = EX_VAR(opline->op1.var);
+
+       if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
+               ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       }
+
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+
+       cache_addr = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
+
+       zend_fetch_property_address(variable_ptr, container, IS_CV, property, IS_CV, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC);
+       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
+               variable_ptr = Z_INDIRECT_P(variable_ptr);
+       }
+
+       value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (UNEXPECTED(Z_TYPE(variable) != IS_INDIRECT)) {
+               zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
+
+
+               if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       } else if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (IS_VAR == IS_VAR &&
+                  opline->extended_value == ZEND_RETURNS_FUNCTION &&
+                          UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
+                               Z_INDIRECT_P(variable_ptr), value_ptr, IS_CV OPLINE_CC EXECUTE_DATA_CC))) {
+
+
+                       if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+
+
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               zend_property_info *prop_info = NULL;
+
+               if (IS_CV == IS_CONST) {
+                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
+               } else {
+                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
+               }
+
+               if (UNEXPECTED(prop_info)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+
+
+                               if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+                               HANDLE_EXCEPTION();
+                       }
+
+                       if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr)) && Z_ISREF_P(variable_ptr)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+                       }
+               }
+               zend_assign_to_variable_reference(variable_ptr, value_ptr);
+               if (prop_info) {
+                       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               }
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+       }
+
+
+       if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);};
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zval *property;
+       zval *container;
+       zval variable, *variable_ptr = &variable;
+       zval *value_ptr;
+       void **cache_addr;
+
+       SAVE_OPLINE();
+
+       container = EX_VAR(opline->op1.var);
+
+       if (IS_CV == IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) {
+               ZEND_VM_TAIL_CALL(zend_this_not_in_object_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+       }
+
+       property = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC);
+
+       cache_addr = (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_RETURNS_FUNCTION) : NULL;
+
+       zend_fetch_property_address(variable_ptr, container, IS_CV, property, IS_CV, cache_addr, BP_VAR_W, 0, 0 OPLINE_CC);
+       if (Z_TYPE_P(variable_ptr) == IS_INDIRECT) {
+               variable_ptr = Z_INDIRECT_P(variable_ptr);
+       }
+
+       value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC);
+
+       if (UNEXPECTED(Z_ISERROR_P(variable_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (UNEXPECTED(Z_TYPE(variable) != IS_INDIRECT)) {
+               zend_throw_error(NULL, "Cannot assign by reference to overloaded object");
+
+
+
+               UNDEF_RESULT();
+               HANDLE_EXCEPTION();
+       } else if (IS_CV == IS_VAR && UNEXPECTED(Z_ISERROR_P(value_ptr))) {
+               variable_ptr = &EG(uninitialized_zval);
+       } else if (IS_CV == IS_VAR &&
+                  opline->extended_value == ZEND_RETURNS_FUNCTION &&
+                          UNEXPECTED(!Z_ISREF_P(value_ptr))) {
+
+               if (UNEXPECTED(!zend_wrong_assign_to_variable_reference(
+                               Z_INDIRECT_P(variable_ptr), value_ptr, IS_CV OPLINE_CC EXECUTE_DATA_CC))) {
+
+
+
+                       UNDEF_RESULT();
+                       HANDLE_EXCEPTION();
+               }
+
+               /* op_data freed by assign_to_variable */
+
+
+               ZEND_VM_NEXT_OPCODE_EX(1, 2);
+       } else {
+               zend_property_info *prop_info = NULL;
+
+               if (IS_CV == IS_CONST) {
+                       prop_info = (zend_property_info *) CACHED_PTR_EX(cache_addr + 2);
+               } else {
+                       prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(container), variable_ptr);
+               }
+
+               if (UNEXPECTED(prop_info)) {
+                       if (!zend_verify_prop_assignable_by_ref(prop_info, value_ptr, EX_USES_STRICT_TYPES())) {
+
+
+
+                               HANDLE_EXCEPTION();
+                       }
+
+                       if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr)) && Z_ISREF_P(variable_ptr)) {
+                               ZEND_REF_DEL_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+                       }
+               }
+               zend_assign_to_variable_reference(variable_ptr, value_ptr);
+               if (prop_info) {
+                       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(variable_ptr), prop_info);
+               }
+       }
+
+       if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+               ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
+       }
+
+
+
+       ZEND_VM_NEXT_OPCODE_EX(1, 2);
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -51518,14 +59426,19 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_ADD_SPEC_CONST_CONST_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_ADD_SPEC_CONST_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_ADD_SPEC_CONST_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_ADD_SPEC_CONST_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
@@ -51533,60 +59446,79 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_ADD_SPEC_TMP_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_ADD_SPEC_TMP_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_ADD_SPEC_TMP_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_ADD_SPEC_TMP_UNUSED_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_VAR_CONST_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_VAR_CONST_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_VAR_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_ADD_SPEC_VAR_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_DIM_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_VAR_CV_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_VAR_CV_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_VAR_CV_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_UNUSED_CONST_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_UNUSED_CV_OBJ_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_CV_CONST_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_CV_CONST_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_CV_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_ADD_SPEC_CV_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_DIM_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_CV_CV_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_CV_CV_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_ADD_SPEC_CV_CV_OBJ_LABEL,
@@ -51594,14 +59526,19 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SUB_SPEC_CONST_CONST_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SUB_SPEC_CONST_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SUB_SPEC_CONST_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SUB_SPEC_CONST_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
@@ -51609,59 +59546,79 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SUB_SPEC_TMP_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SUB_SPEC_TMP_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SUB_SPEC_TMP_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SUB_SPEC_TMP_UNUSED_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_VAR_CONST_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_VAR_CONST_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_VAR_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_SUB_SPEC_VAR_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_DIM_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_VAR_CV_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_VAR_CV_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_VAR_CV_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_UNUSED_CONST_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_UNUSED_CV_OBJ_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_CV_CONST_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_CV_CONST_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_CV_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_SUB_SPEC_CV_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_DIM_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_CV_CV_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_CV_CV_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_SUB_SPEC_CV_CV_OBJ_LABEL,
@@ -51669,15 +59626,19 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_MUL_SPEC_CONST_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_MUL_SPEC_CONST_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_MUL_SPEC_CONST_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_MUL_SPEC_CONST_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
@@ -51685,12 +59646,19 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_MUL_SPEC_TMP_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_MUL_SPEC_TMP_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_MUL_SPEC_TMP_TMPVAR_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_MUL_SPEC_TMP_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
@@ -51698,45 +59666,59 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_VAR_CONST_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_VAR_CONST_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_VAR_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_MUL_SPEC_VAR_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_DIM_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_VAR_CV_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_VAR_CV_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_VAR_CV_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_UNUSED_CONST_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_UNUSED_CV_OBJ_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_CV_CONST_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_CV_CONST_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_CV_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_MUL_SPEC_CV_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_DIM_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_CV_CV_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_CV_CV_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_MUL_SPEC_CV_CV_OBJ_LABEL,
@@ -51744,13 +59726,19 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_DIV_SPEC_CONST_CONST_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_DIV_SPEC_CONST_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_DIV_SPEC_CONST_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_DIV_SPEC_CONST_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
@@ -51758,60 +59746,79 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_DIV_SPEC_TMP_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_DIV_SPEC_TMP_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_DIV_SPEC_TMP_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_DIV_SPEC_TMP_UNUSED_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_VAR_CONST_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_VAR_CONST_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_VAR_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_DIV_SPEC_VAR_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_DIM_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_VAR_CV_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_VAR_CV_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_VAR_CV_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_UNUSED_CONST_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_UNUSED_CV_OBJ_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_CV_CONST_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_CV_CONST_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_CV_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_DIV_SPEC_CV_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_DIM_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_CV_CV_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_CV_CV_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_DIV_SPEC_CV_CV_OBJ_LABEL,
@@ -51819,12 +59826,19 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_MOD_SPEC_CONST_CONST_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_MOD_SPEC_CONST_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_MOD_SPEC_CONST_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_MOD_SPEC_CONST_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
@@ -51832,15 +59846,19 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_MOD_SPEC_TMP_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_MOD_SPEC_TMP_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_MOD_SPEC_TMP_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_MOD_SPEC_TMP_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
@@ -51848,45 +59866,59 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_VAR_CONST_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_VAR_CONST_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_VAR_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_MOD_SPEC_VAR_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_DIM_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_VAR_CV_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_VAR_CV_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_VAR_CV_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_UNUSED_CONST_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_UNUSED_CV_OBJ_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_CV_CONST_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_CV_CONST_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_CV_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_MOD_SPEC_CV_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_DIM_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_CV_CV_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_CV_CV_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_MOD_SPEC_CV_CV_OBJ_LABEL,
@@ -51894,15 +59926,19 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SL_SPEC_CONST_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SL_SPEC_CONST_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SL_SPEC_CONST_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SL_SPEC_CONST_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
@@ -51910,12 +59946,19 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SL_SPEC_TMP_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SL_SPEC_TMP_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SL_SPEC_TMP_TMPVAR_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SL_SPEC_TMP_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
@@ -51923,45 +59966,59 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_ASSIGN_SL_SPEC_VAR_CONST_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_VAR_CONST_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_VAR_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_SL_SPEC_VAR_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_DIM_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_VAR_CV_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_VAR_CV_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_VAR_CV_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_UNUSED_CONST_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_UNUSED_CV_OBJ_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_CV_CONST_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_CV_CONST_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_CV_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_SL_SPEC_CV_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_CV_UNUSED_DIM_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SL_SPEC_CV_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_CV_CV_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_CV_CV_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_SL_SPEC_CV_CV_OBJ_LABEL,
@@ -51969,13 +60026,19 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SR_SPEC_CONST_CONST_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SR_SPEC_CONST_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SR_SPEC_CONST_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SR_SPEC_CONST_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
@@ -51983,60 +60046,79 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SR_SPEC_TMP_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SR_SPEC_TMP_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SR_SPEC_TMP_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SR_SPEC_TMP_UNUSED_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_VAR_CONST_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_VAR_CONST_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_VAR_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_SR_SPEC_VAR_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_DIM_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_VAR_CV_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_VAR_CV_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_VAR_CV_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_UNUSED_CONST_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_UNUSED_CV_OBJ_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_CV_CONST_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_CV_CONST_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_CV_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_SR_SPEC_CV_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_CV_UNUSED_DIM_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_SR_SPEC_CV_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_CV_CV_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_CV_CV_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_SR_SPEC_CV_CV_OBJ_LABEL,
@@ -52044,14 +60126,19 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_CONCAT_SPEC_CONST_CONST_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_CONCAT_SPEC_CONST_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_CONCAT_SPEC_CONST_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_CONCAT_SPEC_CONST_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
@@ -52059,59 +60146,79 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_CONCAT_SPEC_TMP_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_CONCAT_SPEC_TMP_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_CONCAT_SPEC_TMP_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_CONCAT_SPEC_TMP_UNUSED_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_DIM_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CONST_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CV_OBJ_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_DIM_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_CV_CV_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_CV_CV_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_CONCAT_SPEC_CV_CV_OBJ_LABEL,
@@ -52119,15 +60226,19 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_OR_SPEC_CONST_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_OR_SPEC_CONST_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_OR_SPEC_CONST_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_OR_SPEC_CONST_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
@@ -52135,12 +60246,19 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_OR_SPEC_TMP_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_OR_SPEC_TMP_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_OR_SPEC_TMP_TMPVAR_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_OR_SPEC_TMP_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
@@ -52148,45 +60266,59 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_DIM_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CONST_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CV_OBJ_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_DIM_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_CV_CV_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_CV_CV_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_OR_SPEC_CV_CV_OBJ_LABEL,
@@ -52194,13 +60326,19 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_AND_SPEC_CONST_CONST_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_AND_SPEC_CONST_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_AND_SPEC_CONST_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_AND_SPEC_CONST_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
@@ -52208,60 +60346,79 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_AND_SPEC_TMP_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_AND_SPEC_TMP_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_AND_SPEC_TMP_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_AND_SPEC_TMP_UNUSED_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_DIM_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CONST_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CV_OBJ_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_DIM_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_CV_CV_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_CV_CV_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_AND_SPEC_CV_CV_OBJ_LABEL,
@@ -52269,13 +60426,19 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_CONST_CONST_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_CONST_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_CONST_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_CONST_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
@@ -52283,60 +60446,79 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_TMP_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_TMP_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_TMP_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_TMP_UNUSED_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_DIM_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CONST_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CV_OBJ_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_STATIC_PROP_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_DIM_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_STATIC_PROP_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_DIM_LABEL,
                        (void*)&&ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_OBJ_LABEL,
@@ -52344,6 +60526,7 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_LABEL,
                        (void*)&&ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
@@ -53707,15 +61890,506 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_CONST_CONST_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_CONST_TMPVAR_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_CONST_TMPVAR_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_CONST_UNUSED_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_TMP_CONST_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_TMP_TMPVAR_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_TMP_TMPVAR_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_TMP_UNUSED_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_CONST_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_CONST_DIM_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_CONST_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_DIM_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_CV_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_CV_DIM_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_CV_OBJ_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_UNUSED_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_UNUSED_CV_OBJ_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_CONST_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_CONST_DIM_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_CONST_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_CONST_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_UNUSED_DIM_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_UNUSED_STATIC_PROP_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_CV_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_CV_DIM_LABEL,
+                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_CV_OBJ_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_BIND_GLOBAL_SPEC_CV_CONST_LABEL,
+                       (void*)&&ZEND_COALESCE_SPEC_CONST_LABEL,
+                       (void*)&&ZEND_COALESCE_SPEC_TMPVAR_LABEL,
+                       (void*)&&ZEND_COALESCE_SPEC_TMPVAR_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_COALESCE_SPEC_CV_LABEL,
+                       (void*)&&ZEND_SPACESHIP_SPEC_CONST_CONST_LABEL,
+                       (void*)&&ZEND_SPACESHIP_SPEC_CONST_TMPVAR_LABEL,
+                       (void*)&&ZEND_SPACESHIP_SPEC_CONST_TMPVAR_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_SPACESHIP_SPEC_CONST_CV_LABEL,
+                       (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
+                       (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CV_LABEL,
+                       (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
+                       (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CV_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_SPACESHIP_SPEC_CV_CONST_LABEL,
+                       (void*)&&ZEND_SPACESHIP_SPEC_CV_TMPVAR_LABEL,
+                       (void*)&&ZEND_SPACESHIP_SPEC_CV_TMPVAR_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_SPACESHIP_SPEC_CV_CV_LABEL,
+                       (void*)&&ZEND_DECLARE_ANON_CLASS_SPEC_LABEL,
+                       (void*)&&ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_CONST_CONST_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_VAR_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_CV_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_CV_VAR_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_CV_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_VAR_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_CV_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_CV_VAR_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_CV_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_VAR_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_VAR_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_VAR_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_VAR_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_VAR_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_VAR_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_VAR_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_VAR_LABEL,
+                       (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_CONST_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_CONST_VAR_LABEL,
+                       (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_CONST_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_CV_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_CV_VAR_LABEL,
+                       (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_CV_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_VAR_LABEL,
+                       (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_VAR_LABEL,
+                       (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_LABEL,
+                       (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_BIND_LEXICAL_SPEC_TMP_CV_LABEL,
+                       (void*)&&ZEND_BIND_STATIC_SPEC_CV_UNUSED_LABEL,
+                       (void*)&&ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_LABEL,
+                       (void*)&&ZEND_SEND_FUNC_ARG_SPEC_VAR_LABEL,
+                       (void*)&&ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_LABEL,
+                       (void*)&&ZEND_SWITCH_LONG_SPEC_CONST_CONST_LABEL,
+                       (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL,
+                       (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL,
+                       (void*)&&ZEND_SWITCH_STRING_SPEC_CONST_CONST_LABEL,
+                       (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL,
+                       (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL,
+                       (void*)&&ZEND_IN_ARRAY_SPEC_CONST_CONST_LABEL,
+                       (void*)&&ZEND_IN_ARRAY_SPEC_TMP_CONST_LABEL,
+                       (void*)&&ZEND_IN_ARRAY_SPEC_VAR_CONST_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_IN_ARRAY_SPEC_CV_CONST_LABEL,
+                       (void*)&&ZEND_COUNT_SPEC_CONST_UNUSED_LABEL,
+                       (void*)&&ZEND_COUNT_SPEC_TMP_UNUSED_LABEL,
+                       (void*)&&ZEND_COUNT_SPEC_VAR_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_COUNT_SPEC_CV_UNUSED_LABEL,
+                       (void*)&&ZEND_GET_CLASS_SPEC_CONST_UNUSED_LABEL,
+                       (void*)&&ZEND_GET_CLASS_SPEC_TMP_UNUSED_LABEL,
+                       (void*)&&ZEND_GET_CLASS_SPEC_VAR_UNUSED_LABEL,
+                       (void*)&&ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_LABEL,
+                       (void*)&&ZEND_GET_CLASS_SPEC_CV_UNUSED_LABEL,
+                       (void*)&&ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_LABEL,
+                       (void*)&&ZEND_GET_TYPE_SPEC_CONST_UNUSED_LABEL,
+                       (void*)&&ZEND_GET_TYPE_SPEC_TMP_UNUSED_LABEL,
+                       (void*)&&ZEND_GET_TYPE_SPEC_VAR_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_GET_TYPE_SPEC_CV_UNUSED_LABEL,
+                       (void*)&&ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_LABEL,
+                       (void*)&&ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_UNSET_CV_SPEC_CV_UNUSED_LABEL,
+                       (void*)&&ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_LABEL,
+                       (void*)&&ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_LABEL,
+                       (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_CONST_LABEL,
+                       (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_LABEL,
+                       (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_CV_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
@@ -53723,375 +62397,284 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_CONST_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_CONST_DIM_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_CONST_OBJ_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_DIM_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_CV_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_CV_DIM_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_VAR_CV_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_UNUSED_CONST_OBJ_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_CONST_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_TMP_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_VAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_CV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_UNUSED_CV_OBJ_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_CONST_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_CONST_DIM_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_CONST_OBJ_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_CONST_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_TMP_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_VAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_UNUSED_DIM_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_CV_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_CONST_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_TMP_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_VAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_CV_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_CV_DIM_LABEL,
-                       (void*)&&ZEND_ASSIGN_POW_SPEC_CV_CV_OBJ_LABEL,
-                       (void*)&&ZEND_BIND_GLOBAL_SPEC_CV_CONST_LABEL,
-                       (void*)&&ZEND_COALESCE_SPEC_CONST_LABEL,
-                       (void*)&&ZEND_COALESCE_SPEC_TMPVAR_LABEL,
-                       (void*)&&ZEND_COALESCE_SPEC_TMPVAR_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_CV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_COALESCE_SPEC_CV_LABEL,
-                       (void*)&&ZEND_SPACESHIP_SPEC_CONST_CONST_LABEL,
-                       (void*)&&ZEND_SPACESHIP_SPEC_CONST_TMPVAR_LABEL,
-                       (void*)&&ZEND_SPACESHIP_SPEC_CONST_TMPVAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_SPACESHIP_SPEC_CONST_CV_LABEL,
-                       (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CONST_LABEL,
-                       (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
-                       (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CV_LABEL,
-                       (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CONST_LABEL,
-                       (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
-                       (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CONST_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_TMP_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_VAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_SPACESHIP_SPEC_CV_CONST_LABEL,
-                       (void*)&&ZEND_SPACESHIP_SPEC_CV_TMPVAR_LABEL,
-                       (void*)&&ZEND_SPACESHIP_SPEC_CV_TMPVAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_SPACESHIP_SPEC_CV_CV_LABEL,
-                       (void*)&&ZEND_DECLARE_ANON_CLASS_SPEC_LABEL,
-                       (void*)&&ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_CONST_CONST_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_VAR_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_UNUSED_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CONST_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_TMP_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_VAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CV_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CONST_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_TMP_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_VAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_UNUSED_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CONST_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_TMP_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_VAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_CV_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_CV_VAR_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_R_SPEC_CV_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_VAR_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_UNUSED_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CONST_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_TMP_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_VAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CV_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CONST_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_TMP_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_VAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_VAR_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_UNUSED_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_VAR_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_CV_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_CV_VAR_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_W_SPEC_CV_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_VAR_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_VAR_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_VAR_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_VAR_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_VAR_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_VAR_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_VAR_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_CONST_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_TMP_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_VAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_CV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_VAR_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_CONST_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_CONST_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_TMP_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_VAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_VAR_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_UNUSED_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_CV_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_CONST_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_TMP_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_VAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_CV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_VAR_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_VAR_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_VAR_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_CONST_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_VAR_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_UNUSED_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_VAR_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_VAR_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_VAR_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_UNUSED_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_VAR_LABEL,
+                       (void*)&&ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_VAR_LABEL,
+                       (void*)&&ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_CONST_LABEL,
+                       (void*)&&ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_VAR_LABEL,
-                       (void*)&&ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_UNUSED_LABEL,
+                       (void*)&&ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_CONST_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_CONST_VAR_LABEL,
-                       (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_CONST_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR_LABEL,
-                       (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR_LABEL,
-                       (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_UNUSED_LABEL,
+                       (void*)&&ZEND_PRE_INC_STATIC_PROP_SPEC_CV_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_PRE_INC_STATIC_PROP_SPEC_CV_VAR_LABEL,
+                       (void*)&&ZEND_PRE_INC_STATIC_PROP_SPEC_CV_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_VAR_LABEL,
+                       (void*)&&ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_CV_CONST_LABEL,
+                       (void*)&&ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_CV_VAR_LABEL,
-                       (void*)&&ZEND_UNSET_STATIC_PROP_SPEC_CV_UNUSED_LABEL,
+                       (void*)&&ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_VAR_LABEL,
-                       (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_VAR_LABEL,
-                       (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_VAR_LABEL,
-                       (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_UNUSED_LABEL,
+                       (void*)&&ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_VAR_LABEL,
+                       (void*)&&ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_POST_INC_STATIC_PROP_SPEC_CONST_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_POST_INC_STATIC_PROP_SPEC_CONST_VAR_LABEL,
+                       (void*)&&ZEND_POST_INC_STATIC_PROP_SPEC_CONST_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_CONST_LABEL,
+                       (void*)&&ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_VAR_LABEL,
-                       (void*)&&ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_UNUSED_LABEL,
+                       (void*)&&ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST_LABEL,
-                       (void*)&&ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_BIND_LEXICAL_SPEC_TMP_CV_LABEL,
-                       (void*)&&ZEND_BIND_STATIC_SPEC_CV_UNUSED_LABEL,
-                       (void*)&&ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED_LABEL,
-                       (void*)&&ZEND_SEND_FUNC_ARG_SPEC_VAR_LABEL,
-                       (void*)&&ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_LABEL,
-                       (void*)&&ZEND_SWITCH_LONG_SPEC_CONST_CONST_LABEL,
-                       (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL,
-                       (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST_LABEL,
-                       (void*)&&ZEND_SWITCH_STRING_SPEC_CONST_CONST_LABEL,
-                       (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL,
-                       (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL,
-                       (void*)&&ZEND_IN_ARRAY_SPEC_CONST_CONST_LABEL,
-                       (void*)&&ZEND_IN_ARRAY_SPEC_TMP_CONST_LABEL,
-                       (void*)&&ZEND_IN_ARRAY_SPEC_VAR_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_IN_ARRAY_SPEC_CV_CONST_LABEL,
-                       (void*)&&ZEND_COUNT_SPEC_CONST_UNUSED_LABEL,
-                       (void*)&&ZEND_COUNT_SPEC_TMP_UNUSED_LABEL,
-                       (void*)&&ZEND_COUNT_SPEC_VAR_UNUSED_LABEL,
+                       (void*)&&ZEND_POST_INC_STATIC_PROP_SPEC_CV_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_COUNT_SPEC_CV_UNUSED_LABEL,
-                       (void*)&&ZEND_GET_CLASS_SPEC_CONST_UNUSED_LABEL,
-                       (void*)&&ZEND_GET_CLASS_SPEC_TMP_UNUSED_LABEL,
-                       (void*)&&ZEND_GET_CLASS_SPEC_VAR_UNUSED_LABEL,
-                       (void*)&&ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_LABEL,
-                       (void*)&&ZEND_GET_CLASS_SPEC_CV_UNUSED_LABEL,
-                       (void*)&&ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_LABEL,
-                       (void*)&&ZEND_GET_TYPE_SPEC_CONST_UNUSED_LABEL,
-                       (void*)&&ZEND_GET_TYPE_SPEC_TMP_UNUSED_LABEL,
-                       (void*)&&ZEND_GET_TYPE_SPEC_VAR_UNUSED_LABEL,
+                       (void*)&&ZEND_POST_INC_STATIC_PROP_SPEC_CV_VAR_LABEL,
+                       (void*)&&ZEND_POST_INC_STATIC_PROP_SPEC_CV_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_GET_TYPE_SPEC_CV_UNUSED_LABEL,
-                       (void*)&&ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_LABEL,
-                       (void*)&&ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED_LABEL,
+                       (void*)&&ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_VAR_LABEL,
+                       (void*)&&ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED_LABEL,
+                       (void*)&&ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_UNSET_CV_SPEC_CV_UNUSED_LABEL,
-                       (void*)&&ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_LABEL,
-                       (void*)&&ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_LABEL,
-                       (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_CONST_LABEL,
-                       (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_LABEL,
-                       (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_LABEL,
+                       (void*)&&ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_CV_LABEL,
-                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_LABEL,
-                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_LABEL,
-                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_LABEL,
+                       (void*)&&ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_LABEL,
-                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_LABEL,
-                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
-                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
+                       (void*)&&ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_VAR_LABEL,
+                       (void*)&&ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_LABEL,
-                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_LABEL,
-                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
-                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_POST_DEC_STATIC_PROP_SPEC_CV_CONST_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_LABEL,
-                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_LABEL,
-                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_LABEL,
+                       (void*)&&ZEND_POST_DEC_STATIC_PROP_SPEC_CV_VAR_LABEL,
+                       (void*)&&ZEND_POST_DEC_STATIC_PROP_SPEC_CV_UNUSED_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
-                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_LABEL,
                        (void*)&&ZEND_JMP_FORWARD_SPEC_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
@@ -55568,6 +64151,70 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_BOOL_XOR_SPEC_CONST_CONST)
                                ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_ADD_SPEC_CONST_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_ADD_SPEC_CONST_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_ADD_SPEC_CONST_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SUB_SPEC_CONST_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SUB_SPEC_CONST_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_SUB_SPEC_CONST_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_MUL_SPEC_CONST_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_MUL_SPEC_CONST_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_MUL_SPEC_CONST_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_DIV_SPEC_CONST_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_DIV_SPEC_CONST_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_DIV_SPEC_CONST_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_MOD_SPEC_CONST_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_MOD_SPEC_CONST_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_MOD_SPEC_CONST_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SL_SPEC_CONST_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SL_SPEC_CONST_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_SL_SPEC_CONST_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SR_SPEC_CONST_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SR_SPEC_CONST_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_SR_SPEC_CONST_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_CONCAT_SPEC_CONST_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_CONCAT_SPEC_CONST_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_CONCAT_SPEC_CONST_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_OR_SPEC_CONST_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_OR_SPEC_CONST_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_BW_OR_SPEC_CONST_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_AND_SPEC_CONST_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_AND_SPEC_CONST_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_BW_AND_SPEC_CONST_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_XOR_SPEC_CONST_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_XOR_SPEC_CONST_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_BW_XOR_SPEC_CONST_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_POW_SPEC_CONST_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_POW_SPEC_CONST_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_POW_SPEC_CONST_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_CONST):
+                               VM_TRACE(ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_CONST)
+                               ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_CONST):
+                               VM_TRACE(ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_CONST)
+                               ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_POST_INC_STATIC_PROP_SPEC_CONST_CONST):
+                               VM_TRACE(ZEND_POST_INC_STATIC_PROP_SPEC_CONST_CONST)
+                               ZEND_POST_INC_STATIC_PROP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_CONST):
+                               VM_TRACE(ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_CONST)
+                               ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_CONST):
                                VM_TRACE(ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_CONST)
                                ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -55620,6 +64267,26 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_FETCH_LIST_R_SPEC_CONST_CONST)
                                ZEND_FETCH_LIST_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_CONST):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_CONST)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_TMP):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_TMP)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_VAR):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_VAR)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_CV):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_CV)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_CONST):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_CONST)
+                               ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CONST_CONST):
                                VM_TRACE(ZEND_FAST_CONCAT_SPEC_CONST_CONST)
                                ZEND_FAST_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -55808,6 +64475,54 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_SPACESHIP_SPEC_CONST_TMPVAR)
                                ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_ADD_SPEC_CONST_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_ADD_SPEC_CONST_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_ADD_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SUB_SPEC_CONST_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SUB_SPEC_CONST_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_SUB_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_MUL_SPEC_CONST_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_MUL_SPEC_CONST_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_MUL_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_DIV_SPEC_CONST_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_DIV_SPEC_CONST_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_DIV_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_MOD_SPEC_CONST_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_MOD_SPEC_CONST_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_MOD_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SL_SPEC_CONST_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SL_SPEC_CONST_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_SL_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SR_SPEC_CONST_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SR_SPEC_CONST_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_SR_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_CONCAT_SPEC_CONST_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_CONCAT_SPEC_CONST_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_CONCAT_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_OR_SPEC_CONST_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_OR_SPEC_CONST_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_BW_OR_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_AND_SPEC_CONST_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_AND_SPEC_CONST_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_BW_AND_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_XOR_SPEC_CONST_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_XOR_SPEC_CONST_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_BW_XOR_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_POW_SPEC_CONST_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_POW_SPEC_CONST_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_POW_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR):
                                VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR)
                                ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -55876,6 +64591,22 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_YIELD_SPEC_CONST_TMP)
                                ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_VAR):
+                               VM_TRACE(ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_VAR)
+                               ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_VAR):
+                               VM_TRACE(ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_VAR)
+                               ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_POST_INC_STATIC_PROP_SPEC_CONST_VAR):
+                               VM_TRACE(ZEND_POST_INC_STATIC_PROP_SPEC_CONST_VAR)
+                               ZEND_POST_INC_STATIC_PROP_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_VAR):
+                               VM_TRACE(ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_VAR)
+                               ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_VAR):
                                VM_TRACE(ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_VAR)
                                ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -55900,6 +64631,26 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_VAR)
                                ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_CONST):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_CONST)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_TMP):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_TMP)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_VAR):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_VAR)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_CV):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_CV)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_VAR):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_VAR)
+                               ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_UNSET_STATIC_PROP_SPEC_CONST_VAR):
                                VM_TRACE(ZEND_UNSET_STATIC_PROP_SPEC_CONST_VAR)
                                ZEND_UNSET_STATIC_PROP_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -55912,6 +64663,70 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_YIELD_SPEC_CONST_VAR)
                                ZEND_YIELD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_ADD_SPEC_CONST_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_ADD_SPEC_CONST_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_ADD_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SUB_SPEC_CONST_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SUB_SPEC_CONST_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_SUB_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_MUL_SPEC_CONST_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_MUL_SPEC_CONST_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_MUL_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_DIV_SPEC_CONST_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_DIV_SPEC_CONST_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_DIV_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_MOD_SPEC_CONST_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_MOD_SPEC_CONST_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_MOD_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SL_SPEC_CONST_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SL_SPEC_CONST_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_SL_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SR_SPEC_CONST_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SR_SPEC_CONST_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_SR_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_CONCAT_SPEC_CONST_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_CONCAT_SPEC_CONST_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_CONCAT_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_OR_SPEC_CONST_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_OR_SPEC_CONST_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_BW_OR_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_AND_SPEC_CONST_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_AND_SPEC_CONST_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_BW_AND_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_XOR_SPEC_CONST_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_XOR_SPEC_CONST_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_BW_XOR_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_POW_SPEC_CONST_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_POW_SPEC_CONST_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_POW_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_UNUSED):
+                               VM_TRACE(ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_UNUSED)
+                               ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_UNUSED):
+                               VM_TRACE(ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_UNUSED)
+                               ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_POST_INC_STATIC_PROP_SPEC_CONST_UNUSED):
+                               VM_TRACE(ZEND_POST_INC_STATIC_PROP_SPEC_CONST_UNUSED)
+                               ZEND_POST_INC_STATIC_PROP_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_UNUSED):
+                               VM_TRACE(ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_UNUSED)
+                               ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_FETCH_R_SPEC_CONST_UNUSED):
                                VM_TRACE(ZEND_FETCH_R_SPEC_CONST_UNUSED)
                                ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -55964,6 +64779,26 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED)
                                ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_CONST):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_CONST)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_TMP):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_TMP)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_VAR):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_VAR)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_CV):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_CV)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_UNUSED):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_UNUSED)
+                               ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED):
                                VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED)
                                ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -56644,6 +65479,22 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_BOOL_XOR_SPEC_TMPVAR_CONST)
                                ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_CONST):
+                               VM_TRACE(ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_CONST)
+                               ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_CONST):
+                               VM_TRACE(ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_CONST)
+                               ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_CONST):
+                               VM_TRACE(ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_CONST)
+                               ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_CONST):
+                               VM_TRACE(ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_CONST)
+                               ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST):
                                VM_TRACE(ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST)
                                ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -56684,6 +65535,26 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST)
                                ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CONST):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CONST)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_TMP):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_TMP)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_VAR):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_VAR)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CV):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CV)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_CONST):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_CONST)
+                               ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST):
                                VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST)
                                ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -56840,6 +65711,22 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR)
                                ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_VAR):
+                               VM_TRACE(ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_VAR)
+                               ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_VAR):
+                               VM_TRACE(ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_VAR)
+                               ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_VAR):
+                               VM_TRACE(ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_VAR)
+                               ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_VAR):
+                               VM_TRACE(ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_VAR)
+                               ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR):
                                VM_TRACE(ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR)
                                ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -56864,6 +65751,26 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_VAR)
                                ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CONST):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CONST)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_TMP):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_TMP)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_VAR):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_VAR)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CV):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CV)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_VAR):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_VAR)
+                               ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR):
                                VM_TRACE(ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR)
                                ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -56876,6 +65783,22 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_INSTANCEOF_SPEC_TMPVAR_VAR)
                                ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED):
+                               VM_TRACE(ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED)
+                               ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED):
+                               VM_TRACE(ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED)
+                               ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED):
+                               VM_TRACE(ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED)
+                               ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED):
+                               VM_TRACE(ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED)
+                               ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED):
                                VM_TRACE(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED)
                                ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -56924,6 +65847,26 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_UNUSED)
                                ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CONST):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CONST)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_TMP):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_TMP)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_VAR):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_VAR)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CV):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CV)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_UNUSED):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_UNUSED)
+                               ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED):
                                VM_TRACE(ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED)
                                ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57158,6 +66101,54 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST)
                                ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_ADD_SPEC_TMP_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_ADD_SPEC_TMP_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_ADD_SPEC_TMP_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SUB_SPEC_TMP_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SUB_SPEC_TMP_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_SUB_SPEC_TMP_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_MUL_SPEC_TMP_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_MUL_SPEC_TMP_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_MUL_SPEC_TMP_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_DIV_SPEC_TMP_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_DIV_SPEC_TMP_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_DIV_SPEC_TMP_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_MOD_SPEC_TMP_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_MOD_SPEC_TMP_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_MOD_SPEC_TMP_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SL_SPEC_TMP_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SL_SPEC_TMP_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_SL_SPEC_TMP_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SR_SPEC_TMP_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SR_SPEC_TMP_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_SR_SPEC_TMP_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_CONCAT_SPEC_TMP_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_CONCAT_SPEC_TMP_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_CONCAT_SPEC_TMP_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_OR_SPEC_TMP_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_OR_SPEC_TMP_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_BW_OR_SPEC_TMP_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_AND_SPEC_TMP_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_AND_SPEC_TMP_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_BW_AND_SPEC_TMP_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_XOR_SPEC_TMP_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_XOR_SPEC_TMP_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_BW_XOR_SPEC_TMP_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_POW_SPEC_TMP_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_POW_SPEC_TMP_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_POW_SPEC_TMP_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST):
                                VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST)
                                ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57190,6 +66181,54 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_IN_ARRAY_SPEC_TMP_CONST)
                                ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_ADD_SPEC_TMP_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_ADD_SPEC_TMP_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_ADD_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SUB_SPEC_TMP_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SUB_SPEC_TMP_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_SUB_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_MUL_SPEC_TMP_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_MUL_SPEC_TMP_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_MUL_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_DIV_SPEC_TMP_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_DIV_SPEC_TMP_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_DIV_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_MOD_SPEC_TMP_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_MOD_SPEC_TMP_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_MOD_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SL_SPEC_TMP_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SL_SPEC_TMP_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_SL_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SR_SPEC_TMP_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SR_SPEC_TMP_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_SR_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_CONCAT_SPEC_TMP_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_CONCAT_SPEC_TMP_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_CONCAT_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_OR_SPEC_TMP_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_OR_SPEC_TMP_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_BW_OR_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_AND_SPEC_TMP_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_AND_SPEC_TMP_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_BW_AND_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_XOR_SPEC_TMP_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_XOR_SPEC_TMP_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_BW_XOR_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_POW_SPEC_TMP_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_POW_SPEC_TMP_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_POW_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR):
                                VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR)
                                ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57230,6 +66269,54 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_YIELD_SPEC_TMP_VAR)
                                ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_ADD_SPEC_TMP_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_ADD_SPEC_TMP_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_ADD_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SUB_SPEC_TMP_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SUB_SPEC_TMP_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_SUB_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_MUL_SPEC_TMP_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_MUL_SPEC_TMP_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_MUL_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_DIV_SPEC_TMP_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_DIV_SPEC_TMP_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_DIV_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_MOD_SPEC_TMP_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_MOD_SPEC_TMP_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_MOD_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SL_SPEC_TMP_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SL_SPEC_TMP_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_SL_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SR_SPEC_TMP_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SR_SPEC_TMP_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_SR_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_CONCAT_SPEC_TMP_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_CONCAT_SPEC_TMP_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_CONCAT_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_OR_SPEC_TMP_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_OR_SPEC_TMP_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_BW_OR_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_AND_SPEC_TMP_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_AND_SPEC_TMP_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_BW_AND_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_XOR_SPEC_TMP_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_XOR_SPEC_TMP_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_BW_XOR_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_POW_SPEC_TMP_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_POW_SPEC_TMP_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_POW_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED):
                                VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED)
                                ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57496,6 +66583,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_ADD_SPEC_VAR_CONST_OBJ)
                                ZEND_ASSIGN_ADD_SPEC_VAR_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_ADD_SPEC_VAR_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_ADD_SPEC_VAR_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_ADD_SPEC_VAR_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_SUB_SPEC_VAR_CONST):
                                VM_TRACE(ZEND_ASSIGN_SUB_SPEC_VAR_CONST)
                                ZEND_ASSIGN_SUB_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57508,6 +66599,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_SUB_SPEC_VAR_CONST_OBJ)
                                ZEND_ASSIGN_SUB_SPEC_VAR_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SUB_SPEC_VAR_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SUB_SPEC_VAR_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_SUB_SPEC_VAR_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_MUL_SPEC_VAR_CONST):
                                VM_TRACE(ZEND_ASSIGN_MUL_SPEC_VAR_CONST)
                                ZEND_ASSIGN_MUL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57520,6 +66615,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_MUL_SPEC_VAR_CONST_OBJ)
                                ZEND_ASSIGN_MUL_SPEC_VAR_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_MUL_SPEC_VAR_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_MUL_SPEC_VAR_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_MUL_SPEC_VAR_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_DIV_SPEC_VAR_CONST):
                                VM_TRACE(ZEND_ASSIGN_DIV_SPEC_VAR_CONST)
                                ZEND_ASSIGN_DIV_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57532,6 +66631,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_DIV_SPEC_VAR_CONST_OBJ)
                                ZEND_ASSIGN_DIV_SPEC_VAR_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_DIV_SPEC_VAR_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_DIV_SPEC_VAR_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_DIV_SPEC_VAR_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_MOD_SPEC_VAR_CONST):
                                VM_TRACE(ZEND_ASSIGN_MOD_SPEC_VAR_CONST)
                                ZEND_ASSIGN_MOD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57544,6 +66647,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_MOD_SPEC_VAR_CONST_OBJ)
                                ZEND_ASSIGN_MOD_SPEC_VAR_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_MOD_SPEC_VAR_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_MOD_SPEC_VAR_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_MOD_SPEC_VAR_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_SL_SPEC_VAR_CONST):
                                VM_TRACE(ZEND_ASSIGN_SL_SPEC_VAR_CONST)
                                ZEND_ASSIGN_SL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57556,6 +66663,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_SL_SPEC_VAR_CONST_OBJ)
                                ZEND_ASSIGN_SL_SPEC_VAR_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SL_SPEC_VAR_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SL_SPEC_VAR_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_SL_SPEC_VAR_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_SR_SPEC_VAR_CONST):
                                VM_TRACE(ZEND_ASSIGN_SR_SPEC_VAR_CONST)
                                ZEND_ASSIGN_SR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57568,6 +66679,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_SR_SPEC_VAR_CONST_OBJ)
                                ZEND_ASSIGN_SR_SPEC_VAR_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SR_SPEC_VAR_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SR_SPEC_VAR_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_SR_SPEC_VAR_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST):
                                VM_TRACE(ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST)
                                ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57580,6 +66695,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_OBJ)
                                ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST):
                                VM_TRACE(ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST)
                                ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57592,6 +66711,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_OBJ)
                                ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST):
                                VM_TRACE(ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST)
                                ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57604,6 +66727,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_OBJ)
                                ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST):
                                VM_TRACE(ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST)
                                ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57616,6 +66743,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_OBJ)
                                ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_POW_SPEC_VAR_CONST):
                                VM_TRACE(ZEND_ASSIGN_POW_SPEC_VAR_CONST)
                                ZEND_ASSIGN_POW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57628,6 +66759,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_POW_SPEC_VAR_CONST_OBJ)
                                ZEND_ASSIGN_POW_SPEC_VAR_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_POW_SPEC_VAR_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_POW_SPEC_VAR_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_POW_SPEC_VAR_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_VAR_CONST):
                                VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_VAR_CONST)
                                ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57720,6 +66855,14 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED)
                                ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR):
+                               VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR)
+                               ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV):
+                               VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV)
+                               ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST):
                                VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST)
                                ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57764,6 +66907,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_OBJ)
                                ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR):
                                VM_TRACE(ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR)
                                ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57776,6 +66923,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_OBJ)
                                ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR):
                                VM_TRACE(ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR)
                                ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57788,6 +66939,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_OBJ)
                                ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR):
                                VM_TRACE(ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR)
                                ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57800,6 +66955,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_OBJ)
                                ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR):
                                VM_TRACE(ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR)
                                ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57812,6 +66971,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_OBJ)
                                ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR):
                                VM_TRACE(ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR)
                                ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57824,6 +66987,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_OBJ)
                                ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR):
                                VM_TRACE(ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR)
                                ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57836,6 +67003,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_OBJ)
                                ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR):
                                VM_TRACE(ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR)
                                ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57848,6 +67019,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_OBJ)
                                ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR):
                                VM_TRACE(ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR)
                                ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57860,6 +67035,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_OBJ)
                                ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR):
                                VM_TRACE(ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR)
                                ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57872,6 +67051,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_OBJ)
                                ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR):
                                VM_TRACE(ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR)
                                ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57884,6 +67067,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_OBJ)
                                ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR):
                                VM_TRACE(ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR)
                                ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57896,6 +67083,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ)
                                ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR):
                                VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR)
                                ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57980,6 +67171,14 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV)
                                ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR):
+                               VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR)
+                               ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV):
+                               VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV)
+                               ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR):
                                VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR)
                                ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -58048,50 +67247,98 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_DIM)
                                ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_DIM):
                                VM_TRACE(ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_DIM)
                                ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_DIM):
                                VM_TRACE(ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_DIM)
                                ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_DIM):
                                VM_TRACE(ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_DIM)
                                ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_DIM):
                                VM_TRACE(ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_DIM)
                                ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_DIM):
                                VM_TRACE(ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_DIM)
                                ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_DIM):
                                VM_TRACE(ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_DIM)
                                ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_DIM):
                                VM_TRACE(ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_DIM)
                                ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_DIM):
                                VM_TRACE(ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_DIM)
                                ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_DIM):
                                VM_TRACE(ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_DIM)
                                ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_DIM):
                                VM_TRACE(ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_DIM)
                                ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_DIM):
                                VM_TRACE(ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_DIM)
                                ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED):
                                VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED)
                                ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -58404,6 +67651,14 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_REF_SPEC_VAR_CV)
                                ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR):
+                               VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR)
+                               ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV):
+                               VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV)
+                               ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV):
                                VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV)
                                ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -58560,6 +67815,14 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV)
                                ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR):
+                               VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR)
+                               ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV):
+                               VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV)
+                               ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_CONST):
                                VM_TRACE(ZEND_ROPE_INIT_SPEC_UNUSED_CONST)
                                ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -58700,6 +67963,14 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
                                ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR):
+                               VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR)
+                               ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV):
+                               VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV)
+                               ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR):
                                VM_TRACE(ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR)
                                ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -58880,6 +68151,14 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV)
                                ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR):
+                               VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR)
+                               ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV):
+                               VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV)
+                               ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_CV):
                                VM_TRACE(ZEND_ROPE_INIT_SPEC_UNUSED_CV)
                                ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59218,6 +68497,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_ADD_SPEC_CV_CONST_OBJ)
                                ZEND_ASSIGN_ADD_SPEC_CV_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_ADD_SPEC_CV_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_ADD_SPEC_CV_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_ADD_SPEC_CV_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_SUB_SPEC_CV_CONST):
                                VM_TRACE(ZEND_ASSIGN_SUB_SPEC_CV_CONST)
                                ZEND_ASSIGN_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59230,6 +68513,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_SUB_SPEC_CV_CONST_OBJ)
                                ZEND_ASSIGN_SUB_SPEC_CV_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SUB_SPEC_CV_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SUB_SPEC_CV_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_SUB_SPEC_CV_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_MUL_SPEC_CV_CONST):
                                VM_TRACE(ZEND_ASSIGN_MUL_SPEC_CV_CONST)
                                ZEND_ASSIGN_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59242,6 +68529,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_MUL_SPEC_CV_CONST_OBJ)
                                ZEND_ASSIGN_MUL_SPEC_CV_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_MUL_SPEC_CV_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_MUL_SPEC_CV_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_MUL_SPEC_CV_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_DIV_SPEC_CV_CONST):
                                VM_TRACE(ZEND_ASSIGN_DIV_SPEC_CV_CONST)
                                ZEND_ASSIGN_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59254,6 +68545,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_DIV_SPEC_CV_CONST_OBJ)
                                ZEND_ASSIGN_DIV_SPEC_CV_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_DIV_SPEC_CV_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_DIV_SPEC_CV_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_DIV_SPEC_CV_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_MOD_SPEC_CV_CONST):
                                VM_TRACE(ZEND_ASSIGN_MOD_SPEC_CV_CONST)
                                ZEND_ASSIGN_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59266,6 +68561,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_MOD_SPEC_CV_CONST_OBJ)
                                ZEND_ASSIGN_MOD_SPEC_CV_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_MOD_SPEC_CV_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_MOD_SPEC_CV_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_MOD_SPEC_CV_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_SL_SPEC_CV_CONST):
                                VM_TRACE(ZEND_ASSIGN_SL_SPEC_CV_CONST)
                                ZEND_ASSIGN_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59278,6 +68577,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_SL_SPEC_CV_CONST_OBJ)
                                ZEND_ASSIGN_SL_SPEC_CV_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SL_SPEC_CV_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SL_SPEC_CV_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_SL_SPEC_CV_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_SR_SPEC_CV_CONST):
                                VM_TRACE(ZEND_ASSIGN_SR_SPEC_CV_CONST)
                                ZEND_ASSIGN_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59290,6 +68593,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_SR_SPEC_CV_CONST_OBJ)
                                ZEND_ASSIGN_SR_SPEC_CV_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SR_SPEC_CV_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SR_SPEC_CV_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_SR_SPEC_CV_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_CONCAT_SPEC_CV_CONST):
                                VM_TRACE(ZEND_ASSIGN_CONCAT_SPEC_CV_CONST)
                                ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59302,6 +68609,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_OBJ)
                                ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_BW_OR_SPEC_CV_CONST):
                                VM_TRACE(ZEND_ASSIGN_BW_OR_SPEC_CV_CONST)
                                ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59314,6 +68625,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_OBJ)
                                ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_BW_AND_SPEC_CV_CONST):
                                VM_TRACE(ZEND_ASSIGN_BW_AND_SPEC_CV_CONST)
                                ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59326,6 +68641,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_OBJ)
                                ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST):
                                VM_TRACE(ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST)
                                ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59338,6 +68657,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_OBJ)
                                ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_POW_SPEC_CV_CONST):
                                VM_TRACE(ZEND_ASSIGN_POW_SPEC_CV_CONST)
                                ZEND_ASSIGN_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59350,6 +68673,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_POW_SPEC_CV_CONST_OBJ)
                                ZEND_ASSIGN_POW_SPEC_CV_CONST_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_POW_SPEC_CV_CONST_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_POW_SPEC_CV_CONST_STATIC_PROP)
+                               ZEND_ASSIGN_POW_SPEC_CV_CONST_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_CV_CONST):
                                VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_CV_CONST)
                                ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59366,6 +68693,22 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_POST_DEC_OBJ_SPEC_CV_CONST)
                                ZEND_POST_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_PRE_INC_STATIC_PROP_SPEC_CV_CONST):
+                               VM_TRACE(ZEND_PRE_INC_STATIC_PROP_SPEC_CV_CONST)
+                               ZEND_PRE_INC_STATIC_PROP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_CONST):
+                               VM_TRACE(ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_CONST)
+                               ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_POST_INC_STATIC_PROP_SPEC_CV_CONST):
+                               VM_TRACE(ZEND_POST_INC_STATIC_PROP_SPEC_CV_CONST)
+                               ZEND_POST_INC_STATIC_PROP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_POST_DEC_STATIC_PROP_SPEC_CV_CONST):
+                               VM_TRACE(ZEND_POST_DEC_STATIC_PROP_SPEC_CV_CONST)
+                               ZEND_POST_DEC_STATIC_PROP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_FETCH_STATIC_PROP_R_SPEC_CV_CONST):
                                VM_TRACE(ZEND_FETCH_STATIC_PROP_R_SPEC_CV_CONST)
                                ZEND_FETCH_STATIC_PROP_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59454,6 +68797,22 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV)
                                ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_CONST):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_CONST)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_TMP):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_TMP)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_VAR):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_VAR)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_CV):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_CV)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST):
                                VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST)
                                ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59478,6 +68837,18 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED)
                                ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR):
+                               VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR)
+                               ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV):
+                               VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV)
+                               ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_CONST):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_CONST)
+                               ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CV_CONST):
                                VM_TRACE(ZEND_FAST_CONCAT_SPEC_CV_CONST)
                                ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59630,6 +69001,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_OBJ)
                                ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR):
                                VM_TRACE(ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR)
                                ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59642,6 +69017,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_OBJ)
                                ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR):
                                VM_TRACE(ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR)
                                ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59654,6 +69033,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_OBJ)
                                ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR):
                                VM_TRACE(ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR)
                                ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59666,6 +69049,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_OBJ)
                                ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR):
                                VM_TRACE(ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR)
                                ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59678,6 +69065,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_OBJ)
                                ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_SL_SPEC_CV_TMPVAR):
                                VM_TRACE(ZEND_ASSIGN_SL_SPEC_CV_TMPVAR)
                                ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59690,6 +69081,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_OBJ)
                                ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_SR_SPEC_CV_TMPVAR):
                                VM_TRACE(ZEND_ASSIGN_SR_SPEC_CV_TMPVAR)
                                ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59702,6 +69097,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_OBJ)
                                ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR):
                                VM_TRACE(ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR)
                                ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59714,6 +69113,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_OBJ)
                                ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR):
                                VM_TRACE(ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR)
                                ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59726,6 +69129,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_OBJ)
                                ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR):
                                VM_TRACE(ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR)
                                ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59738,6 +69145,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_OBJ)
                                ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR):
                                VM_TRACE(ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR)
                                ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59750,6 +69161,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_OBJ)
                                ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_POW_SPEC_CV_TMPVAR):
                                VM_TRACE(ZEND_ASSIGN_POW_SPEC_CV_TMPVAR)
                                ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59762,6 +69177,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ)
                                ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_STATIC_PROP)
+                               ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR):
                                VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR)
                                ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59858,6 +69277,14 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV)
                                ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR):
+                               VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR)
+                               ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV):
+                               VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV)
+                               ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CV_TMPVAR):
                                VM_TRACE(ZEND_FAST_CONCAT_SPEC_CV_TMPVAR)
                                ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59922,6 +69349,22 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR)
                                ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_PRE_INC_STATIC_PROP_SPEC_CV_VAR):
+                               VM_TRACE(ZEND_PRE_INC_STATIC_PROP_SPEC_CV_VAR)
+                               ZEND_PRE_INC_STATIC_PROP_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_VAR):
+                               VM_TRACE(ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_VAR)
+                               ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_POST_INC_STATIC_PROP_SPEC_CV_VAR):
+                               VM_TRACE(ZEND_POST_INC_STATIC_PROP_SPEC_CV_VAR)
+                               ZEND_POST_INC_STATIC_PROP_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_POST_DEC_STATIC_PROP_SPEC_CV_VAR):
+                               VM_TRACE(ZEND_POST_DEC_STATIC_PROP_SPEC_CV_VAR)
+                               ZEND_POST_DEC_STATIC_PROP_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_FETCH_STATIC_PROP_R_SPEC_CV_VAR):
                                VM_TRACE(ZEND_FETCH_STATIC_PROP_R_SPEC_CV_VAR)
                                ZEND_FETCH_STATIC_PROP_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59946,6 +69389,22 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_VAR)
                                ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_CONST):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_CONST)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_TMP):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_TMP)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_VAR):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_VAR)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_CV):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_CV)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED):
                                VM_TRACE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED)
                                ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59958,6 +69417,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_REF_SPEC_CV_VAR)
                                ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_VAR):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_VAR)
+                               ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_UNSET_STATIC_PROP_SPEC_CV_VAR):
                                VM_TRACE(ZEND_UNSET_STATIC_PROP_SPEC_CV_VAR)
                                ZEND_UNSET_STATIC_PROP_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59978,50 +69441,114 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_DIM)
                                ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_DIM):
                                VM_TRACE(ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_DIM)
                                ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_DIM):
                                VM_TRACE(ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_DIM)
                                ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_DIM):
                                VM_TRACE(ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_DIM)
                                ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_DIM):
                                VM_TRACE(ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_DIM)
                                ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_SL_SPEC_CV_UNUSED_DIM):
                                VM_TRACE(ZEND_ASSIGN_SL_SPEC_CV_UNUSED_DIM)
                                ZEND_ASSIGN_SL_SPEC_CV_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SL_SPEC_CV_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SL_SPEC_CV_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_SL_SPEC_CV_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_SR_SPEC_CV_UNUSED_DIM):
                                VM_TRACE(ZEND_ASSIGN_SR_SPEC_CV_UNUSED_DIM)
                                ZEND_ASSIGN_SR_SPEC_CV_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_SR_SPEC_CV_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_SR_SPEC_CV_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_SR_SPEC_CV_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_DIM):
                                VM_TRACE(ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_DIM)
                                ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_DIM):
                                VM_TRACE(ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_DIM)
                                ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_DIM):
                                VM_TRACE(ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_DIM)
                                ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_DIM):
                                VM_TRACE(ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_DIM)
                                ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_POW_SPEC_CV_UNUSED_DIM):
                                VM_TRACE(ZEND_ASSIGN_POW_SPEC_CV_UNUSED_DIM)
                                ZEND_ASSIGN_POW_SPEC_CV_UNUSED_DIM_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_POW_SPEC_CV_UNUSED_STATIC_PROP):
+                               VM_TRACE(ZEND_ASSIGN_POW_SPEC_CV_UNUSED_STATIC_PROP)
+                               ZEND_ASSIGN_POW_SPEC_CV_UNUSED_STATIC_PROP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_PRE_INC_STATIC_PROP_SPEC_CV_UNUSED):
+                               VM_TRACE(ZEND_PRE_INC_STATIC_PROP_SPEC_CV_UNUSED)
+                               ZEND_PRE_INC_STATIC_PROP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_UNUSED):
+                               VM_TRACE(ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_UNUSED)
+                               ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_POST_INC_STATIC_PROP_SPEC_CV_UNUSED):
+                               VM_TRACE(ZEND_POST_INC_STATIC_PROP_SPEC_CV_UNUSED)
+                               ZEND_POST_INC_STATIC_PROP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_POST_DEC_STATIC_PROP_SPEC_CV_UNUSED):
+                               VM_TRACE(ZEND_POST_DEC_STATIC_PROP_SPEC_CV_UNUSED)
+                               ZEND_POST_DEC_STATIC_PROP_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_FETCH_R_SPEC_CV_UNUSED):
                                VM_TRACE(ZEND_FETCH_R_SPEC_CV_UNUSED)
                                ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -60082,6 +69609,22 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED)
                                ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_CONST):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_CONST)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_TMP):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_TMP)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_VAR):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_VAR)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_CV):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_CV)
+                               ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST):
                                VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST)
                                ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -60098,6 +69641,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV)
                                ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_UNUSED):
+                               VM_TRACE(ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_UNUSED)
+                               ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED):
                                VM_TRACE(ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED)
                                ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -60502,6 +70049,14 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ASSIGN_REF_SPEC_CV_CV)
                                ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR):
+                               VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR)
+                               ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV):
+                               VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV)
+                               ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CV_CV):
                                VM_TRACE(ZEND_FAST_CONCAT_SPEC_CV_CV)
                                ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -61074,15 +70629,19 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_ADD_SPEC_CONST_CONST_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_ADD_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_ADD_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_ADD_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -61090,59 +70649,79 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_ADD_SPEC_TMP_CONST_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_ADD_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_ADD_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_ADD_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_VAR_CONST_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_VAR_CONST_DIM_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_VAR_CONST_OBJ_HANDLER,
+               ZEND_ASSIGN_ADD_SPEC_VAR_CONST_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_DIM_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_VAR_CV_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_VAR_CV_DIM_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_VAR_CV_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_UNUSED_CONST_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_UNUSED_TMPVAR_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_UNUSED_TMPVAR_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_UNUSED_CV_OBJ_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_CV_CONST_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_CV_CONST_DIM_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_CV_CONST_OBJ_HANDLER,
+               ZEND_ASSIGN_ADD_SPEC_CV_CONST_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_DIM_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_CV_CV_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_CV_CV_DIM_HANDLER,
                ZEND_ASSIGN_ADD_SPEC_CV_CV_OBJ_HANDLER,
@@ -61150,15 +70729,19 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SUB_SPEC_CONST_CONST_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SUB_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SUB_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SUB_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -61166,12 +70749,19 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SUB_SPEC_TMP_CONST_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SUB_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SUB_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SUB_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -61179,45 +70769,59 @@ void zend_vm_init(void)
                ZEND_ASSIGN_SUB_SPEC_VAR_CONST_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_VAR_CONST_DIM_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_VAR_CONST_OBJ_HANDLER,
+               ZEND_ASSIGN_SUB_SPEC_VAR_CONST_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_DIM_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_VAR_CV_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_VAR_CV_DIM_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_VAR_CV_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_UNUSED_CONST_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_UNUSED_TMPVAR_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_UNUSED_TMPVAR_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_UNUSED_CV_OBJ_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_CV_CONST_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_CV_CONST_DIM_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_CV_CONST_OBJ_HANDLER,
+               ZEND_ASSIGN_SUB_SPEC_CV_CONST_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_DIM_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_CV_CV_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_CV_CV_DIM_HANDLER,
                ZEND_ASSIGN_SUB_SPEC_CV_CV_OBJ_HANDLER,
@@ -61225,12 +70829,19 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_MUL_SPEC_CONST_CONST_STATIC_PROP_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_MUL_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_MUL_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_MUL_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -61238,15 +70849,19 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_MUL_SPEC_TMP_CONST_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_MUL_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_MUL_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_MUL_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -61254,45 +70869,59 @@ void zend_vm_init(void)
                ZEND_ASSIGN_MUL_SPEC_VAR_CONST_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_VAR_CONST_DIM_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_VAR_CONST_OBJ_HANDLER,
+               ZEND_ASSIGN_MUL_SPEC_VAR_CONST_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_DIM_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_VAR_CV_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_VAR_CV_DIM_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_VAR_CV_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_UNUSED_CONST_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_UNUSED_TMPVAR_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_UNUSED_TMPVAR_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_UNUSED_CV_OBJ_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_CV_CONST_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_CV_CONST_DIM_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_CV_CONST_OBJ_HANDLER,
+               ZEND_ASSIGN_MUL_SPEC_CV_CONST_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_DIM_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_CV_CV_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_CV_CV_DIM_HANDLER,
                ZEND_ASSIGN_MUL_SPEC_CV_CV_OBJ_HANDLER,
@@ -61300,13 +70929,19 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_DIV_SPEC_CONST_CONST_STATIC_PROP_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_DIV_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_DIV_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_DIV_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -61314,60 +70949,79 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_DIV_SPEC_TMP_CONST_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_DIV_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_DIV_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_DIV_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_VAR_CONST_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_VAR_CONST_DIM_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_VAR_CONST_OBJ_HANDLER,
+               ZEND_ASSIGN_DIV_SPEC_VAR_CONST_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_DIM_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_VAR_CV_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_VAR_CV_DIM_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_VAR_CV_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_UNUSED_CONST_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_UNUSED_TMPVAR_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_UNUSED_TMPVAR_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_UNUSED_CV_OBJ_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_CV_CONST_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_CV_CONST_DIM_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_CV_CONST_OBJ_HANDLER,
+               ZEND_ASSIGN_DIV_SPEC_CV_CONST_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_DIM_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_CV_CV_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_CV_CV_DIM_HANDLER,
                ZEND_ASSIGN_DIV_SPEC_CV_CV_OBJ_HANDLER,
@@ -61375,14 +71029,19 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_MOD_SPEC_CONST_CONST_STATIC_PROP_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_MOD_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_MOD_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_MOD_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -61390,59 +71049,79 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_MOD_SPEC_TMP_CONST_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_MOD_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_MOD_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_MOD_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_VAR_CONST_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_VAR_CONST_DIM_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_VAR_CONST_OBJ_HANDLER,
+               ZEND_ASSIGN_MOD_SPEC_VAR_CONST_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_DIM_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_VAR_CV_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_VAR_CV_DIM_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_VAR_CV_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_UNUSED_CONST_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_UNUSED_TMPVAR_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_UNUSED_TMPVAR_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_UNUSED_CV_OBJ_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_CV_CONST_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_CV_CONST_DIM_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_CV_CONST_OBJ_HANDLER,
+               ZEND_ASSIGN_MOD_SPEC_CV_CONST_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_DIM_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_CV_CV_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_CV_CV_DIM_HANDLER,
                ZEND_ASSIGN_MOD_SPEC_CV_CV_OBJ_HANDLER,
@@ -61450,15 +71129,19 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SL_SPEC_CONST_CONST_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SL_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SL_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SL_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -61466,12 +71149,19 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SL_SPEC_TMP_CONST_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SL_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SL_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SL_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -61479,45 +71169,59 @@ void zend_vm_init(void)
                ZEND_ASSIGN_SL_SPEC_VAR_CONST_HANDLER,
                ZEND_ASSIGN_SL_SPEC_VAR_CONST_DIM_HANDLER,
                ZEND_ASSIGN_SL_SPEC_VAR_CONST_OBJ_HANDLER,
+               ZEND_ASSIGN_SL_SPEC_VAR_CONST_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_DIM_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_SL_SPEC_VAR_CV_HANDLER,
                ZEND_ASSIGN_SL_SPEC_VAR_CV_DIM_HANDLER,
                ZEND_ASSIGN_SL_SPEC_VAR_CV_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_SL_SPEC_UNUSED_CONST_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_SL_SPEC_UNUSED_TMPVAR_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_SL_SPEC_UNUSED_TMPVAR_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_SL_SPEC_UNUSED_CV_OBJ_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_SL_SPEC_CV_CONST_HANDLER,
                ZEND_ASSIGN_SL_SPEC_CV_CONST_DIM_HANDLER,
                ZEND_ASSIGN_SL_SPEC_CV_CONST_OBJ_HANDLER,
+               ZEND_ASSIGN_SL_SPEC_CV_CONST_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_HANDLER,
                ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_HANDLER,
                ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_SL_SPEC_CV_UNUSED_DIM_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SL_SPEC_CV_UNUSED_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_SL_SPEC_CV_CV_HANDLER,
                ZEND_ASSIGN_SL_SPEC_CV_CV_DIM_HANDLER,
                ZEND_ASSIGN_SL_SPEC_CV_CV_OBJ_HANDLER,
@@ -61525,12 +71229,19 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SR_SPEC_CONST_CONST_STATIC_PROP_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SR_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SR_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SR_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -61538,15 +71249,19 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SR_SPEC_TMP_CONST_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SR_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SR_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SR_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -61554,45 +71269,59 @@ void zend_vm_init(void)
                ZEND_ASSIGN_SR_SPEC_VAR_CONST_HANDLER,
                ZEND_ASSIGN_SR_SPEC_VAR_CONST_DIM_HANDLER,
                ZEND_ASSIGN_SR_SPEC_VAR_CONST_OBJ_HANDLER,
+               ZEND_ASSIGN_SR_SPEC_VAR_CONST_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_DIM_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_SR_SPEC_VAR_CV_HANDLER,
                ZEND_ASSIGN_SR_SPEC_VAR_CV_DIM_HANDLER,
                ZEND_ASSIGN_SR_SPEC_VAR_CV_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_SR_SPEC_UNUSED_CONST_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_SR_SPEC_UNUSED_TMPVAR_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_SR_SPEC_UNUSED_TMPVAR_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_SR_SPEC_UNUSED_CV_OBJ_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_SR_SPEC_CV_CONST_HANDLER,
                ZEND_ASSIGN_SR_SPEC_CV_CONST_DIM_HANDLER,
                ZEND_ASSIGN_SR_SPEC_CV_CONST_OBJ_HANDLER,
+               ZEND_ASSIGN_SR_SPEC_CV_CONST_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_HANDLER,
                ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_HANDLER,
                ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_SR_SPEC_CV_UNUSED_DIM_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_SR_SPEC_CV_UNUSED_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_SR_SPEC_CV_CV_HANDLER,
                ZEND_ASSIGN_SR_SPEC_CV_CV_DIM_HANDLER,
                ZEND_ASSIGN_SR_SPEC_CV_CV_OBJ_HANDLER,
@@ -61600,13 +71329,19 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_CONCAT_SPEC_CONST_CONST_STATIC_PROP_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_CONCAT_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_CONCAT_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_CONCAT_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -61614,60 +71349,79 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_CONCAT_SPEC_TMP_CONST_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_CONCAT_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_CONCAT_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_CONCAT_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_DIM_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_OBJ_HANDLER,
+               ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_DIM_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_DIM_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CONST_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMPVAR_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMPVAR_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CV_OBJ_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_DIM_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_OBJ_HANDLER,
+               ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_DIM_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_CV_CV_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_CV_CV_DIM_HANDLER,
                ZEND_ASSIGN_CONCAT_SPEC_CV_CV_OBJ_HANDLER,
@@ -61675,14 +71429,19 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_OR_SPEC_CONST_CONST_STATIC_PROP_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_OR_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_OR_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_OR_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -61690,59 +71449,79 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_OR_SPEC_TMP_CONST_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_OR_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_OR_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_OR_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_DIM_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_OBJ_HANDLER,
+               ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_DIM_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_DIM_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CONST_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMPVAR_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMPVAR_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CV_OBJ_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_DIM_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_OBJ_HANDLER,
+               ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_DIM_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_CV_CV_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_CV_CV_DIM_HANDLER,
                ZEND_ASSIGN_BW_OR_SPEC_CV_CV_OBJ_HANDLER,
@@ -61750,15 +71529,19 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_AND_SPEC_CONST_CONST_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_AND_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_AND_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_AND_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -61766,12 +71549,19 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_AND_SPEC_TMP_CONST_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_AND_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_AND_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_AND_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -61779,45 +71569,59 @@ void zend_vm_init(void)
                ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_DIM_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_OBJ_HANDLER,
+               ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_DIM_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_DIM_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CONST_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMPVAR_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMPVAR_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CV_OBJ_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_DIM_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_OBJ_HANDLER,
+               ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_DIM_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_CV_CV_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_CV_CV_DIM_HANDLER,
                ZEND_ASSIGN_BW_AND_SPEC_CV_CV_OBJ_HANDLER,
@@ -61825,12 +71629,19 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_XOR_SPEC_CONST_CONST_STATIC_PROP_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_XOR_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_XOR_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_XOR_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -61838,15 +71649,19 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_XOR_SPEC_TMP_CONST_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_XOR_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_XOR_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_XOR_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -61854,45 +71669,59 @@ void zend_vm_init(void)
                ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_DIM_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_OBJ_HANDLER,
+               ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_DIM_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_DIM_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CONST_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMPVAR_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMPVAR_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CV_OBJ_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_DIM_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_OBJ_HANDLER,
+               ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_DIM_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_DIM_HANDLER,
                ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_OBJ_HANDLER,
@@ -61900,6 +71729,7 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED_HANDLER,
                ZEND_PRE_INC_SPEC_VAR_RETVAL_USED_HANDLER,
                ZEND_NULL_HANDLER,
@@ -63263,13 +73093,19 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_POW_SPEC_CONST_CONST_STATIC_PROP_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_POW_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_POW_SPEC_CONST_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_POW_SPEC_CONST_UNUSED_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -63277,15 +73113,19 @@ void zend_vm_init(void)
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_POW_SPEC_TMP_CONST_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_POW_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_POW_SPEC_TMP_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_POW_SPEC_TMP_UNUSED_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -63293,48 +73133,63 @@ void zend_vm_init(void)
                ZEND_ASSIGN_POW_SPEC_VAR_CONST_HANDLER,
                ZEND_ASSIGN_POW_SPEC_VAR_CONST_DIM_HANDLER,
                ZEND_ASSIGN_POW_SPEC_VAR_CONST_OBJ_HANDLER,
+               ZEND_ASSIGN_POW_SPEC_VAR_CONST_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_DIM_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_POW_SPEC_VAR_CV_HANDLER,
                ZEND_ASSIGN_POW_SPEC_VAR_CV_DIM_HANDLER,
                ZEND_ASSIGN_POW_SPEC_VAR_CV_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_POW_SPEC_UNUSED_CONST_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_POW_SPEC_UNUSED_CV_OBJ_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_ASSIGN_POW_SPEC_CV_CONST_HANDLER,
                ZEND_ASSIGN_POW_SPEC_CV_CONST_DIM_HANDLER,
                ZEND_ASSIGN_POW_SPEC_CV_CONST_OBJ_HANDLER,
+               ZEND_ASSIGN_POW_SPEC_CV_CONST_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_HANDLER,
                ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_HANDLER,
                ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM_HANDLER,
                ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ_HANDLER,
+               ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_STATIC_PROP_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ASSIGN_POW_SPEC_CV_UNUSED_DIM_HANDLER,
                ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_POW_SPEC_CV_UNUSED_STATIC_PROP_HANDLER,
                ZEND_ASSIGN_POW_SPEC_CV_CV_HANDLER,
                ZEND_ASSIGN_POW_SPEC_CV_CV_DIM_HANDLER,
                ZEND_ASSIGN_POW_SPEC_CV_CV_OBJ_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_BIND_GLOBAL_SPEC_CV_CONST_HANDLER,
                ZEND_COALESCE_SPEC_CONST_HANDLER,
                ZEND_COALESCE_SPEC_TMPVAR_HANDLER,
@@ -63648,6 +73503,381 @@ void zend_vm_init(void)
                ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_CONST_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_TMP_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_VAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_CV_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_CONST_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_TMP_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_VAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_CV_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_CONST_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_TMP_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_VAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_CV_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CONST_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_TMP_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_VAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CV_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CONST_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_TMP_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_VAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CV_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CONST_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_TMP_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_VAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CV_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CONST_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_TMP_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_VAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CV_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CONST_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_TMP_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_VAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CV_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CONST_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_TMP_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_VAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CV_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_CONST_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_TMP_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_VAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_CV_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_CONST_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_TMP_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_VAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_CV_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_CONST_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_VAR_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_UNUSED_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_CONST_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_VAR_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_UNUSED_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_CONST_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_VAR_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_UNUSED_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_CONST_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_VAR_HANDLER,
+               ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_UNUSED_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_CONST_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_VAR_HANDLER,
+               ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_UNUSED_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_CONST_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_VAR_HANDLER,
+               ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_CONST_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_VAR_HANDLER,
+               ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_PRE_INC_STATIC_PROP_SPEC_CV_CONST_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_PRE_INC_STATIC_PROP_SPEC_CV_VAR_HANDLER,
+               ZEND_PRE_INC_STATIC_PROP_SPEC_CV_UNUSED_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_CONST_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_VAR_HANDLER,
+               ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_UNUSED_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_CONST_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_VAR_HANDLER,
+               ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_CONST_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_VAR_HANDLER,
+               ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_CONST_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_VAR_HANDLER,
+               ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_UNUSED_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_POST_INC_STATIC_PROP_SPEC_CONST_CONST_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_POST_INC_STATIC_PROP_SPEC_CONST_VAR_HANDLER,
+               ZEND_POST_INC_STATIC_PROP_SPEC_CONST_UNUSED_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_CONST_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_VAR_HANDLER,
+               ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_CONST_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_VAR_HANDLER,
+               ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_POST_INC_STATIC_PROP_SPEC_CV_CONST_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_POST_INC_STATIC_PROP_SPEC_CV_VAR_HANDLER,
+               ZEND_POST_INC_STATIC_PROP_SPEC_CV_UNUSED_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_CONST_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_VAR_HANDLER,
+               ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_UNUSED_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_CONST_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_VAR_HANDLER,
+               ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_CONST_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_VAR_HANDLER,
+               ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_POST_DEC_STATIC_PROP_SPEC_CV_CONST_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_POST_DEC_STATIC_PROP_SPEC_CV_VAR_HANDLER,
+               ZEND_POST_DEC_STATIC_PROP_SPEC_CV_UNUSED_HANDLER,
+               ZEND_NULL_HANDLER,
                ZEND_JMP_FORWARD_SPEC_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -64568,183 +74798,190 @@ void zend_vm_init(void)
                461 | SPEC_RULE_OP1,
                466 | SPEC_RULE_OP1,
                471 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
-               546 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
-               621 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
-               696 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
+               571 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
+               671 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
                771 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
-               846 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
-               921 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
-               996 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
+               871 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
+               971 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
                1071 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
-               1146 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
-               1221 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
-               1296 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL,
-               1306 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL,
-               1316 | SPEC_RULE_OP1,
-               1321 | SPEC_RULE_OP1,
-               1326 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_RETVAL,
-               1376 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1401 | SPEC_RULE_OP1,
-               1406,
-               1407,
-               1408 | SPEC_RULE_OP1,
-               1413 | SPEC_RULE_OP1,
-               1418 | SPEC_RULE_OP1,
-               1423 | SPEC_RULE_OP1,
-               1428 | SPEC_RULE_OP1,
-               1433 | SPEC_RULE_OP2,
-               1438,
-               1439 | SPEC_RULE_QUICK_ARG,
-               1441 | SPEC_RULE_OP1,
-               1446 | SPEC_RULE_OP1,
-               1451 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1476 | SPEC_RULE_OP2,
-               1481 | SPEC_RULE_OP2,
-               1486 | SPEC_RULE_OP2,
-               1491,
-               1492,
-               1493,
-               1494 | SPEC_RULE_RETVAL,
-               1496,
-               1497 | SPEC_RULE_OP1,
-               1502,
-               1503,
-               1504 | SPEC_RULE_OP1,
-               1509 | SPEC_RULE_OP1 | SPEC_RULE_QUICK_ARG,
-               1519 | SPEC_RULE_OP1,
-               1524 | SPEC_RULE_OP1,
-               1529,
-               1530,
-               1531 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1556 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1581 | SPEC_RULE_OP1,
-               1586 | SPEC_RULE_OP1,
-               1591 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1616 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1641 | SPEC_RULE_OP1,
-               1646,
-               1647 | SPEC_RULE_OP1,
-               1652 | SPEC_RULE_OP1,
-               1657 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1682 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1707 | SPEC_RULE_OP1,
-               1712 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1737 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1762 | SPEC_RULE_OP1,
-               1767 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1792 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1817 | SPEC_RULE_OP1,
-               1822 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1847 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1872 | SPEC_RULE_OP1,
-               1877 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1902 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               1171 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
+               1271 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
+               1371 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
+               1471 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
+               1571 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL,
+               1581 | SPEC_RULE_OP1 | SPEC_RULE_RETVAL,
+               1591 | SPEC_RULE_OP1,
+               1596 | SPEC_RULE_OP1,
+               1601 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_RETVAL,
+               1651 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               1676 | SPEC_RULE_OP1,
+               1681,
+               1682,
+               1683 | SPEC_RULE_OP1,
+               1688 | SPEC_RULE_OP1,
+               1693 | SPEC_RULE_OP1,
+               1698 | SPEC_RULE_OP1,
+               1703 | SPEC_RULE_OP1,
+               1708 | SPEC_RULE_OP2,
+               1713,
+               1714 | SPEC_RULE_QUICK_ARG,
+               1716 | SPEC_RULE_OP1,
+               1721 | SPEC_RULE_OP1,
+               1726 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               1751 | SPEC_RULE_OP2,
+               1756 | SPEC_RULE_OP2,
+               1761 | SPEC_RULE_OP2,
+               1766,
+               1767,
+               1768,
+               1769 | SPEC_RULE_RETVAL,
+               1771,
+               1772 | SPEC_RULE_OP1,
+               1777,
+               1778,
+               1779 | SPEC_RULE_OP1,
+               1784 | SPEC_RULE_OP1 | SPEC_RULE_QUICK_ARG,
+               1794 | SPEC_RULE_OP1,
+               1799 | SPEC_RULE_OP1,
+               1804,
+               1805,
+               1806 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               1831 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               1856 | SPEC_RULE_OP1,
+               1861 | SPEC_RULE_OP1,
+               1866 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               1891 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               1916 | SPEC_RULE_OP1,
+               1921,
+               1922 | SPEC_RULE_OP1,
                1927 | SPEC_RULE_OP1,
                1932 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
                1957 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               1982 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2007,
-               2008 | SPEC_RULE_QUICK_ARG,
-               2010,
-               2011,
-               2012,
-               2013,
-               2014,
-               2015,
-               2016,
-               2017 | SPEC_RULE_OP1,
-               2022 | SPEC_RULE_OP2,
-               2027 | SPEC_RULE_OP1,
-               2032 | SPEC_RULE_OP1,
-               2037 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2062 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2087 | SPEC_RULE_OP1,
-               2092 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2117 | SPEC_RULE_OP1 | SPEC_RULE_QUICK_ARG,
-               2127 | SPEC_RULE_OP1,
-               2132 | SPEC_RULE_OP2,
-               2137,
-               2138 | SPEC_RULE_OP1,
-               2143 | SPEC_RULE_OP1,
-               2148,
-               2149 | SPEC_RULE_OP1,
-               2154 | SPEC_RULE_OP1,
-               2159 | SPEC_RULE_OP1,
-               2164,
-               2165,
-               2166 | SPEC_RULE_OP2,
-               2171 | SPEC_RULE_RETVAL,
-               2173 | SPEC_RULE_RETVAL,
-               2175 | SPEC_RULE_RETVAL,
+               1982 | SPEC_RULE_OP1,
+               1987 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2012 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2037 | SPEC_RULE_OP1,
+               2042 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2067 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2092 | SPEC_RULE_OP1,
+               2097 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2122 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2147 | SPEC_RULE_OP1,
+               2152 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
                2177 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2202 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2227 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2252 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2277 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
-               2402,
-               2403 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2428,
-               2429,
-               2430,
-               2431 | SPEC_RULE_OP1,
-               2436,
-               3941,
-               2437,
-               3941,
-               2438 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
-               2563 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2588,
-               2589,
-               2590,
-               2591 | SPEC_RULE_OP1,
-               2596,
-               3941,
-               3941,
-               2597,
-               2598,
-               2599,
-               2600,
-               2601 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2626 | SPEC_RULE_OP1,
-               2631,
-               2632,
-               2633,
-               2634,
-               2635 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2660 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
-               2735,
-               2736 | SPEC_RULE_OP1,
-               2741 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2766,
-               2767,
-               2768 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2793 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2818 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2843 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2868 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2893 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2918 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2943 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               2968 | SPEC_RULE_OP1,
-               2973,
-               2974,
-               2975,
-               2976,
-               2977,
-               2978 | SPEC_RULE_OP1,
-               2983 | SPEC_RULE_OP1,
-               2988 | SPEC_RULE_OP1,
-               2993 | SPEC_RULE_OP1,
-               2998 | SPEC_RULE_OP1,
-               3003,
-               3004 | SPEC_RULE_OP1,
-               3009,
-               3010 | SPEC_RULE_OP1,
-               3015,
-               3016 | SPEC_RULE_ISSET,
-               3018 | SPEC_RULE_OP2,
-               3023 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-               3941
+               2202 | SPEC_RULE_OP1,
+               2207 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2232 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2257 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2282,
+               2283 | SPEC_RULE_QUICK_ARG,
+               2285,
+               2286,
+               2287,
+               2288,
+               2289,
+               2290,
+               2291,
+               2292 | SPEC_RULE_OP1,
+               2297 | SPEC_RULE_OP2,
+               2302 | SPEC_RULE_OP1,
+               2307 | SPEC_RULE_OP1,
+               2312 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2337 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2362 | SPEC_RULE_OP1,
+               2367 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2392 | SPEC_RULE_OP1 | SPEC_RULE_QUICK_ARG,
+               2402 | SPEC_RULE_OP1,
+               2407 | SPEC_RULE_OP2,
+               2412,
+               2413 | SPEC_RULE_OP1,
+               2418 | SPEC_RULE_OP1,
+               2423,
+               2424 | SPEC_RULE_OP1,
+               2429 | SPEC_RULE_OP1,
+               2434 | SPEC_RULE_OP1,
+               2439,
+               2440,
+               2441 | SPEC_RULE_OP2,
+               2446 | SPEC_RULE_RETVAL,
+               2448 | SPEC_RULE_RETVAL,
+               2450 | SPEC_RULE_RETVAL,
+               2452 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2477 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2502 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2527 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2552 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
+               2677,
+               2678 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2703,
+               2704,
+               2705,
+               2706 | SPEC_RULE_OP1,
+               2711,
+               4616,
+               2712,
+               4616,
+               2713 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
+               2838 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2863,
+               2864,
+               2865,
+               2866 | SPEC_RULE_OP1,
+               2871,
+               4616,
+               4616,
+               2872,
+               2873,
+               2874,
+               2875,
+               2876 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2901 | SPEC_RULE_OP1,
+               2906,
+               2907,
+               2908,
+               2909,
+               2910 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               2935 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_DIM_OBJ,
+               3035,
+               3036 | SPEC_RULE_OP1,
+               3041 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3066,
+               3067,
+               3068 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3093 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3118 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3143 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3168 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3193 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3218 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3243 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3268 | SPEC_RULE_OP1,
+               3273,
+               3274,
+               3275,
+               3276,
+               3277,
+               3278 | SPEC_RULE_OP1,
+               3283 | SPEC_RULE_OP1,
+               3288 | SPEC_RULE_OP1,
+               3293 | SPEC_RULE_OP1,
+               3298 | SPEC_RULE_OP1,
+               3303,
+               3304 | SPEC_RULE_OP1,
+               3309,
+               3310 | SPEC_RULE_OP1,
+               3315,
+               3316 | SPEC_RULE_ISSET,
+               3318 | SPEC_RULE_OP2,
+               3323 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3348 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
+               3473 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
+               3598 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3623 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3648 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3673 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3698 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               4616
        };
 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
        zend_opcode_handler_funcs = labels;
@@ -64853,11 +75090,13 @@ static const void* ZEND_FASTCALL zend_vm_get_opcode_handler_ex(uint32_t spec, co
                } else if (spec & SPEC_RULE_OP_DATA) {
                        offset = offset * 5 + zend_vm_decode[(op + 1)->op1_type];
                } else if (spec & SPEC_RULE_DIM_OBJ) {
-                       offset = offset * 3;
+                       offset = offset * 4;
                        if (op->extended_value == ZEND_ASSIGN_DIM) {
                                offset += 1;
                        } else if (op->extended_value == ZEND_ASSIGN_OBJ) {
                                offset += 2;
+               } else if (op->extended_value == ZEND_ASSIGN_STATIC_PROP) {
+                       offset += 3;
                        }
                } else if (spec & SPEC_RULE_ISSET) {
                        offset = offset * 2 + (op->extended_value & ZEND_ISEMPTY);
@@ -64947,7 +75186,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 = 3049 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3724 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
                                if (op->op1_type < op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -64955,7 +75194,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 = 3074 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3749 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
                                if (op->op1_type < op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -64963,7 +75202,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 = 3099 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3774 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
                                if (op->op1_type < op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -64974,17 +75213,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 = 3124 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3799 | 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 = 3149 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3824 | 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 = 3174 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3849 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                        }
                        break;
                case ZEND_MUL:
@@ -64995,17 +75234,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 = 3199 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3874 | 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 = 3224 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3899 | 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 = 3249 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3924 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
                        }
                        break;
                case ZEND_IS_EQUAL:
@@ -65016,12 +75255,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 = 3274 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+                               spec = 3949 | 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 = 3349 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+                               spec = 4024 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
                        }
                        break;
                case ZEND_IS_NOT_EQUAL:
@@ -65032,12 +75271,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 = 3424 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+                               spec = 4099 | 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 = 3499 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+                               spec = 4174 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
                        }
                        break;
                case ZEND_IS_SMALLER:
@@ -65045,12 +75284,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 = 3574 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 4249 | 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 = 3649 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 4324 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                        }
                        break;
                case ZEND_IS_SMALLER_OR_EQUAL:
@@ -65058,75 +75297,75 @@ 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 = 3724 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 4399 | 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 = 3799 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 4474 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                        }
                        break;
                case ZEND_QM_ASSIGN:
                        if (op1_info == MAY_BE_DOUBLE) {
-                               spec = 3892 | SPEC_RULE_OP1;
+                               spec = 4567 | 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 = 3897 | SPEC_RULE_OP1;
+                               spec = 4572 | SPEC_RULE_OP1;
                        }
                        break;
                case ZEND_PRE_INC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 3874 | SPEC_RULE_RETVAL;
+                               spec = 4549 | SPEC_RULE_RETVAL;
                        } else if (op1_info == MAY_BE_LONG) {
-                               spec = 3876 | SPEC_RULE_RETVAL;
+                               spec = 4551 | SPEC_RULE_RETVAL;
                        } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
-                               spec = 3878 | SPEC_RULE_RETVAL;
+                               spec = 4553 | SPEC_RULE_RETVAL;
                        }
                        break;
                case ZEND_PRE_DEC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 3880 | SPEC_RULE_RETVAL;
+                               spec = 4555 | SPEC_RULE_RETVAL;
                        } else if (op1_info == MAY_BE_LONG) {
-                               spec = 3882 | SPEC_RULE_RETVAL;
+                               spec = 4557 | SPEC_RULE_RETVAL;
                        } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
-                               spec = 3884 | SPEC_RULE_RETVAL;
+                               spec = 4559 | SPEC_RULE_RETVAL;
                        }
                        break;
                case ZEND_POST_INC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 3886;
+                               spec = 4561;
                        } else if (op1_info == MAY_BE_LONG) {
-                               spec = 3887;
+                               spec = 4562;
                        } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
-                               spec = 3888;
+                               spec = 4563;
                        }
                        break;
                case ZEND_POST_DEC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 3889;
+                               spec = 4564;
                        } else if (op1_info == MAY_BE_LONG) {
-                               spec = 3890;
+                               spec = 4565;
                        } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
-                               spec = 3891;
+                               spec = 4566;
                        }
                        break;
                case ZEND_JMP:
                        if (OP_JMP_ADDR(op, op->op1) > op) {
-                               spec = 3048;
+                               spec = 3723;
                        }
                        break;
                case ZEND_SEND_VAL:
                        if (op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) {
-                               spec = 3937;
+                               spec = 4612;
                        }
                        break;
                case ZEND_SEND_VAR_EX:
                        if (op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
-                               spec = 3932 | SPEC_RULE_OP1;
+                               spec = 4607 | 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 = 3939 | SPEC_RULE_RETVAL;
+                               spec = 4614 | SPEC_RULE_RETVAL;
                        }
                        break;
                case ZEND_FETCH_DIM_R:
@@ -65134,17 +75373,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 = 3902 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 4577 | 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 = 3938;
+                               spec = 4613;
                        }
                        break;
                case ZEND_SEND_VAR:
                        if ((op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
-                               spec = 3927 | SPEC_RULE_OP1;
+                               spec = 4602 | SPEC_RULE_OP1;
                        }
                        break;
                case ZEND_BW_OR:

diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php
index d1092788d4b87b42f280527cfbf532277d9a09c0..cbba3732019232e8be707a5c3bcc56fa9972dcfd 100755 (executable)
--- a/Zend/zend_vm_gen.php
+++ b/Zend/zend_vm_gen.php
@@ -76,6 +76,8 @@ $vm_op_flags = array(
        "ZEND_VM_EXT_CACHE_SLOT"  => 1<<18,
        "ZEND_VM_EXT_ARRAY_INIT"  => 1<<19,
        "ZEND_VM_EXT_REF"         => 1<<20,
+       "ZEND_VM_EXT_FETCH_REF"   => 1<<21,
+       "ZEND_VM_EXT_DIM_OBJ_WRITE" => 1<<22,
        "ZEND_VM_EXT_MASK"        => 0x0f000000,
        "ZEND_VM_EXT_NUM"         => 0x01000000,
        "ZEND_VM_EXT_LAST_CATCH"  => 0x02000000,
@@ -129,8 +131,10 @@ $vm_ext_decode = array(
        "TYPE_MASK"            => ZEND_VM_EXT_TYPE_MASK,
        "ISSET"                => ZEND_VM_EXT_ISSET,
        "REF"                  => ZEND_VM_EXT_REF,
+       "FETCH_REF"            => ZEND_VM_EXT_FETCH_REF,
        "SRC"                  => ZEND_VM_EXT_SRC,
        "CACHE_SLOT"           => ZEND_VM_EXT_CACHE_SLOT,
+       "DIM_OBJ_WRITE"        => ZEND_VM_EXT_DIM_OBJ_WRITE,
 );
 
 $vm_kind_name = array(
@@ -567,6 +571,17 @@ $op_data_get_zval_ptr_deref = array(
        "TMPVARCV" => "???",
 );
 
+$op_data_get_zval_ptr_ptr = array(
+       "ANY"      => "get_zval_ptr_ptr((opline+1)->op1_type, (opline+1)->op1, &free_op_data, \\1)",
+       "TMP"      => "NULL",
+       "VAR"      => "_get_zval_ptr_ptr_var((opline+1)->op1.var, &free_op_data EXECUTE_DATA_CC)",
+       "CONST"    => "NULL",
+       "UNUSED"   => "NULL",
+       "CV"       => "_get_zval_ptr_cv_\\1((opline+1)->op1.var EXECUTE_DATA_CC)",
+       "TMPVAR"   => "???",
+       "TMPVARCV" => "???",
+);
+
 $op_data_free_op = array(
        "ANY"      => "FREE_OP(free_op_data)",
        "TMP"      => "zval_ptr_dtor_nogc(free_op_data)",
@@ -578,6 +593,17 @@ $op_data_free_op = array(
        "TMPVARCV" => "???",
 );
 
+$op_data_free_op_var_ptr = array(
+       "ANY"      => "if (free_op_data) {zval_ptr_dtor_nogc(free_op_data);}",
+       "TMP"      => "",
+       "VAR"      => "if (UNEXPECTED(free_op_data)) {zval_ptr_dtor_nogc(free_op_data);}",
+       "CONST"    => "",
+       "UNUSED"   => "",
+       "CV"       => "",
+       "TMPVAR"   => "???",
+       "TMPVARCV" => "???",
+);
+
 $op_data_free_unfetched = array(
        "ANY"      => "FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var)",
        "TMP"      => "zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var))",
@@ -669,9 +695,11 @@ function helper_name($name, $spec, $op1, $op2, $extra_spec) {
        return $name.($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2].$extra;
 }
 
-function opcode_name($name, $spec, $op1, $op2) {
+function opcode_name($name, $spec, $op1, $op2, $extra_spec) {
        global $prefix, $opnames, $opcodes;
 
+       $extra = "";
+
        if (isset($opnames[$name])) {
                $opcode = $opcodes[$opnames[$name]];
                // If we haven't helper with specified spicialized operands then
@@ -710,8 +738,12 @@ function opcode_name($name, $spec, $op1, $op2) {
                                return "ZEND_NULL";
                        }
                }
+               /* forward common specs (e.g. in ZEND_VM_DISPATCH_TO_HANDLER) */
+               if (isset($extra_spec, $opcode["spec"])) {
+                       $extra = extra_spec_name(array_intersect_key($extra_spec, $opcode["spec"]));
+               }
        }
-       return $name.($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2];
+       return $name.($spec?"_SPEC":"").$prefix[$op1].$prefix[$op2].$extra;
 }
 
 // Formats condition, protecting it by parentheses when needed.
@@ -742,8 +774,9 @@ function gen_code($f, $spec, $kind, $export, $code, $op1, $op2, $name, $extra_sp
                $op1_free, $op2_free, $op1_free_unfetched, $op2_free_unfetched,
                $op1_free_op, $op2_free_op, $op1_free_op_if_var, $op2_free_op_if_var,
                $op1_free_op_var_ptr, $op2_free_op_var_ptr, $prefix,
-               $op_data_type, $op_data_get_zval_ptr, $op_data_get_zval_ptr_deref,
-               $op_data_free_op, $op_data_free_unfetched;
+               $op_data_type, $op_data_get_zval_ptr,
+               $op_data_get_zval_ptr_deref, $op_data_get_zval_ptr_ptr,
+               $op_data_free_op, $op_data_free_op_var_ptr, $op_data_free_unfetched;
 
        // Specializing
        $code = preg_replace(
@@ -793,7 +826,9 @@ function gen_code($f, $spec, $kind, $export, $code, $op1, $op2, $name, $extra_sp
                        "/OP_DATA_TYPE/",
                        "/GET_OP_DATA_ZVAL_PTR\(([^)]*)\)/",
                        "/GET_OP_DATA_ZVAL_PTR_DEREF\(([^)]*)\)/",
+                       "/GET_OP_DATA_ZVAL_PTR_PTR\(([^)]*)\)/",
                        "/FREE_OP_DATA\(\)/",
+                       "/FREE_OP_DATA_VAR_PTR\(\)/",
                        "/FREE_UNFETCHED_OP_DATA\(\)/",
                        "/RETURN_VALUE_USED\(opline\)/",
                        "/arg_num <= MAX_ARG_FLAG_NUM/",
@@ -801,6 +836,7 @@ function gen_code($f, $spec, $kind, $export, $code, $op1, $op2, $name, $extra_sp
                        "/opline->extended_value\s*==\s*0/",
                        "/opline->extended_value\s*==\s*ZEND_ASSIGN_DIM/",
                        "/opline->extended_value\s*==\s*ZEND_ASSIGN_OBJ/",
+                       "/opline->extended_value\s*==\s*ZEND_ASSIGN_STATIC_PROP/",
                        "/opline->extended_value\s*&\s*ZEND_ISEMPTY/",
                        "/opline->extended_value\s*&\s*~\s*ZEND_ISEMPTY/",
                ),
@@ -850,7 +886,9 @@ function gen_code($f, $spec, $kind, $export, $code, $op1, $op2, $name, $extra_sp
                        $op_data_type[isset($extra_spec['OP_DATA']) ? $extra_spec['OP_DATA'] : "ANY"],
                        $op_data_get_zval_ptr[isset($extra_spec['OP_DATA']) ? $extra_spec['OP_DATA'] : "ANY"],
                        $op_data_get_zval_ptr_deref[isset($extra_spec['OP_DATA']) ? $extra_spec['OP_DATA'] : "ANY"],
+                       $op_data_get_zval_ptr_ptr[isset($extra_spec['OP_DATA']) ? $extra_spec['OP_DATA'] : "ANY"],
                        $op_data_free_op[isset($extra_spec['OP_DATA']) ? $extra_spec['OP_DATA'] : "ANY"],
+                       $op_data_free_op_var_ptr[isset($extra_spec['OP_DATA']) ? $extra_spec['OP_DATA'] : "ANY"],
                        $op_data_free_unfetched[isset($extra_spec['OP_DATA']) ? $extra_spec['OP_DATA'] : "ANY"],
                        isset($extra_spec['RETVAL']) ? $extra_spec['RETVAL'] : "RETURN_VALUE_USED(opline)",
                        isset($extra_spec['QUICK_ARG']) ? $extra_spec['QUICK_ARG'] : "arg_num <= MAX_ARG_FLAG_NUM",
@@ -869,6 +907,9 @@ function gen_code($f, $spec, $kind, $export, $code, $op1, $op2, $name, $extra_sp
                        isset($extra_spec['DIM_OBJ']) ?
                                ($extra_spec['DIM_OBJ'] == 2 ? "1" : "0")
                                : "\\0",
+                       isset($extra_spec['DIM_OBJ']) ?
+                               ($extra_spec['DIM_OBJ'] == 3 ? "1" : "0")
+                               : "\\0",
                        isset($extra_spec['ISSET']) ?
                                ($extra_spec['ISSET'] == 0 ? "0" : "1")
                                : "\\0",
@@ -929,7 +970,7 @@ function gen_code($f, $spec, $kind, $export, $code, $op1, $op2, $name, $extra_sp
                                        if (strncasecmp($matches[0], "EXECUTE_DATA", strlen("EXECUTE_DATA")) == 0) {
                                                return "execute_data";
                                        } else if (strncasecmp($matches[0], "ZEND_VM_DISPATCH_TO_HANDLER", strlen("ZEND_VM_DISPATCH_TO_HANDLER")) == 0) {
-                                               return "ZEND_VM_TAIL_CALL(" . opcode_name($matches[1], $spec, $op1, $op2) . "_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU))";
+                                               return "ZEND_VM_TAIL_CALL(" . opcode_name($matches[1], $spec, $op1, $op2, $extra_spec) . "_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU))";
                                        } else {
                                                // ZEND_VM_DISPATCH_TO_HELPER
                                                if (isset($matches[2])) {
@@ -953,7 +994,7 @@ function gen_code($f, $spec, $kind, $export, $code, $op1, $op2, $name, $extra_sp
                                        if (strncasecmp($matches[0], "EXECUTE_DATA", strlen("EXECUTE_DATA")) == 0) {
                                                return "execute_data";
                                        } else if (strncasecmp($matches[0], "ZEND_VM_DISPATCH_TO_HANDLER", strlen("ZEND_VM_DISPATCH_TO_HANDLER")) == 0) {
-                                               return "goto " . opcode_name($matches[1], $spec, $op1, $op2) . "_LABEL";
+                                               return "goto " . opcode_name($matches[1], $spec, $op1, $op2, $extra_spec) . "_LABEL";
                                        } else {
                                                // ZEND_VM_DISPATCH_TO_HELPER
                                                if (isset($matches[2])) {
@@ -977,7 +1018,7 @@ function gen_code($f, $spec, $kind, $export, $code, $op1, $op2, $name, $extra_sp
                                        if (strncasecmp($matches[0], "EXECUTE_DATA", strlen("EXECUTE_DATA")) == 0) {
                                                return "execute_data";
                                        } else if (strncasecmp($matches[0], "ZEND_VM_DISPATCH_TO_HANDLER", strlen("ZEND_VM_DISPATCH_TO_HANDLER")) == 0) {
-                                               return "goto " . opcode_name($matches[1], $spec, $op1, $op2) . "_LABEL";
+                                               return "goto " . opcode_name($matches[1], $spec, $op1, $op2, $extra_spec) . "_LABEL";
                                        } else {
                                                // ZEND_VM_DISPATCH_TO_HELPER
                                                if (isset($matches[2])) {
@@ -1055,7 +1096,9 @@ function skip_extra_spec_function($op1, $op2, $extra_spec) {
        }
 
        if (isset($extra_spec["DIM_OBJ"]) &&
-           (($op2 == "UNUSED" && $extra_spec["DIM_OBJ"] != 1) ||
+           ((($op1 == "CONST" || $op1 == "TMP") && $extra_spec["DIM_OBJ"] != 3) ||
+            ($op2 == "UNUSED" && $extra_spec["DIM_OBJ"] != 1 && $extra_spec["DIM_OBJ"] != 3) ||
+            ($op2 == "CV" && $extra_spec["DIM_OBJ"] == 3) ||
             ($op1 == "UNUSED" && $extra_spec["DIM_OBJ"] != 2))) {
            // Skip useless handlers
                return true;
@@ -1579,6 +1622,8 @@ function extra_spec_name($extra_spec) {
                        $s .= "_DIM";
                } else if ($extra_spec["DIM_OBJ"] == 2) {
                        $s .= "_OBJ";
+               } else if ($extra_spec["DIM_OBJ"] == 3) {
+                       $s .= "_STATIC_PROP";
                }
        }
        if (isset($extra_spec["ISSET"])) {
@@ -2281,7 +2326,7 @@ function parse_spec_rules($def, $lineno, $str) {
                                        $ret["SMART_BRANCH"] = array(0, 1, 2);
                                        break;
                                case "DIM_OBJ":
-                                       $ret["DIM_OBJ"] = array(0, 1, 2);
+                                       $ret["DIM_OBJ"] = array(0, 1, 2, 3);
                                        break;
                                case "NO_CONST_CONST":
                                        $ret["NO_CONST_CONST"] = array(1);
@@ -2722,11 +2767,13 @@ function gen_vm($def, $skel) {
                        }
                        if (isset($used_extra_spec["DIM_OBJ"])) {
                                out($f, "\t\t{$else}if (spec & SPEC_RULE_DIM_OBJ) {\n");
-                               out($f, "\t\t\toffset = offset * 3;\n");
+                               out($f, "\t\t\toffset = offset * 4;\n");
                                out($f, "\t\t\tif (op->extended_value == ZEND_ASSIGN_DIM) {\n");
                                out($f, "\t\t\t\toffset += 1;\n");
                                out($f, "\t\t\t} else if (op->extended_value == ZEND_ASSIGN_OBJ) {\n");
                                out($f, "\t\t\t\toffset += 2;\n");
+                               out($f, "\t\t} else if (op->extended_value == ZEND_ASSIGN_STATIC_PROP) {\n");
+                               out($f, "\t\t\toffset += 3;\n");
                                out($f, "\t\t\t}\n");
                                $else = "} else ";
                        }

diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h
index 65342d343bc89c82107d494fbc02efe9984932b4..93e0c6ffeb76e0b50a8dfd3aab6d28440843076f 100644 (file)
--- a/Zend/zend_vm_handlers.h
+++ b/Zend/zend_vm_handlers.h
@@ -256,1816 +256,2140 @@
        _(467, ZEND_QM_ASSIGN_SPEC_TMP) \
        _(468, ZEND_QM_ASSIGN_SPEC_VAR) \
        _(470, ZEND_QM_ASSIGN_SPEC_CV) \
-       _(501, ZEND_ASSIGN_ADD_SPEC_VAR_CONST) \
-       _(502, ZEND_ASSIGN_ADD_SPEC_VAR_CONST_DIM) \
-       _(503, ZEND_ASSIGN_ADD_SPEC_VAR_CONST_OBJ) \
-       _(504, ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR) \
-       _(505, ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_DIM) \
-       _(506, ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_OBJ) \
-       _(507, ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR) \
-       _(508, ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_DIM) \
-       _(509, ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_OBJ) \
-       _(511, ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_DIM) \
-       _(513, ZEND_ASSIGN_ADD_SPEC_VAR_CV) \
-       _(514, ZEND_ASSIGN_ADD_SPEC_VAR_CV_DIM) \
-       _(515, ZEND_ASSIGN_ADD_SPEC_VAR_CV_OBJ) \
-       _(518, ZEND_ASSIGN_ADD_SPEC_UNUSED_CONST_OBJ) \
-       _(521, ZEND_ASSIGN_ADD_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(524, ZEND_ASSIGN_ADD_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(530, ZEND_ASSIGN_ADD_SPEC_UNUSED_CV_OBJ) \
-       _(531, ZEND_ASSIGN_ADD_SPEC_CV_CONST) \
-       _(532, ZEND_ASSIGN_ADD_SPEC_CV_CONST_DIM) \
-       _(533, ZEND_ASSIGN_ADD_SPEC_CV_CONST_OBJ) \
-       _(534, ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR) \
-       _(535, ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_DIM) \
-       _(536, ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_OBJ) \
-       _(537, ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR) \
-       _(538, ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_DIM) \
-       _(539, ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_OBJ) \
-       _(541, ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_DIM) \
-       _(543, ZEND_ASSIGN_ADD_SPEC_CV_CV) \
-       _(544, ZEND_ASSIGN_ADD_SPEC_CV_CV_DIM) \
-       _(545, ZEND_ASSIGN_ADD_SPEC_CV_CV_OBJ) \
-       _(576, ZEND_ASSIGN_SUB_SPEC_VAR_CONST) \
-       _(577, ZEND_ASSIGN_SUB_SPEC_VAR_CONST_DIM) \
-       _(578, ZEND_ASSIGN_SUB_SPEC_VAR_CONST_OBJ) \
-       _(579, ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR) \
-       _(580, ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_DIM) \
-       _(581, ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_OBJ) \
-       _(582, ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR) \
-       _(583, ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_DIM) \
-       _(584, ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_OBJ) \
-       _(586, ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_DIM) \
-       _(588, ZEND_ASSIGN_SUB_SPEC_VAR_CV) \
-       _(589, ZEND_ASSIGN_SUB_SPEC_VAR_CV_DIM) \
-       _(590, ZEND_ASSIGN_SUB_SPEC_VAR_CV_OBJ) \
-       _(593, ZEND_ASSIGN_SUB_SPEC_UNUSED_CONST_OBJ) \
-       _(596, ZEND_ASSIGN_SUB_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(599, ZEND_ASSIGN_SUB_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(605, ZEND_ASSIGN_SUB_SPEC_UNUSED_CV_OBJ) \
-       _(606, ZEND_ASSIGN_SUB_SPEC_CV_CONST) \
-       _(607, ZEND_ASSIGN_SUB_SPEC_CV_CONST_DIM) \
-       _(608, ZEND_ASSIGN_SUB_SPEC_CV_CONST_OBJ) \
-       _(609, ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR) \
-       _(610, ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_DIM) \
-       _(611, ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_OBJ) \
-       _(612, ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR) \
-       _(613, ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_DIM) \
-       _(614, ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_OBJ) \
-       _(616, ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_DIM) \
-       _(618, ZEND_ASSIGN_SUB_SPEC_CV_CV) \
-       _(619, ZEND_ASSIGN_SUB_SPEC_CV_CV_DIM) \
-       _(620, ZEND_ASSIGN_SUB_SPEC_CV_CV_OBJ) \
-       _(651, ZEND_ASSIGN_MUL_SPEC_VAR_CONST) \
-       _(652, ZEND_ASSIGN_MUL_SPEC_VAR_CONST_DIM) \
-       _(653, ZEND_ASSIGN_MUL_SPEC_VAR_CONST_OBJ) \
-       _(654, ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR) \
-       _(655, ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_DIM) \
-       _(656, ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_OBJ) \
-       _(657, ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR) \
-       _(658, ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_DIM) \
-       _(659, ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_OBJ) \
-       _(661, ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_DIM) \
-       _(663, ZEND_ASSIGN_MUL_SPEC_VAR_CV) \
-       _(664, ZEND_ASSIGN_MUL_SPEC_VAR_CV_DIM) \
-       _(665, ZEND_ASSIGN_MUL_SPEC_VAR_CV_OBJ) \
-       _(668, ZEND_ASSIGN_MUL_SPEC_UNUSED_CONST_OBJ) \
-       _(671, ZEND_ASSIGN_MUL_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(674, ZEND_ASSIGN_MUL_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(680, ZEND_ASSIGN_MUL_SPEC_UNUSED_CV_OBJ) \
-       _(681, ZEND_ASSIGN_MUL_SPEC_CV_CONST) \
-       _(682, ZEND_ASSIGN_MUL_SPEC_CV_CONST_DIM) \
-       _(683, ZEND_ASSIGN_MUL_SPEC_CV_CONST_OBJ) \
-       _(684, ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR) \
-       _(685, ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_DIM) \
-       _(686, ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_OBJ) \
-       _(687, ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR) \
-       _(688, ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_DIM) \
-       _(689, ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_OBJ) \
-       _(691, ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_DIM) \
-       _(693, ZEND_ASSIGN_MUL_SPEC_CV_CV) \
-       _(694, ZEND_ASSIGN_MUL_SPEC_CV_CV_DIM) \
-       _(695, ZEND_ASSIGN_MUL_SPEC_CV_CV_OBJ) \
-       _(726, ZEND_ASSIGN_DIV_SPEC_VAR_CONST) \
-       _(727, ZEND_ASSIGN_DIV_SPEC_VAR_CONST_DIM) \
-       _(728, ZEND_ASSIGN_DIV_SPEC_VAR_CONST_OBJ) \
-       _(729, ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR) \
-       _(730, ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_DIM) \
-       _(731, ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_OBJ) \
-       _(732, ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR) \
-       _(733, ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_DIM) \
-       _(734, ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_OBJ) \
-       _(736, ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_DIM) \
-       _(738, ZEND_ASSIGN_DIV_SPEC_VAR_CV) \
-       _(739, ZEND_ASSIGN_DIV_SPEC_VAR_CV_DIM) \
-       _(740, ZEND_ASSIGN_DIV_SPEC_VAR_CV_OBJ) \
-       _(743, ZEND_ASSIGN_DIV_SPEC_UNUSED_CONST_OBJ) \
-       _(746, ZEND_ASSIGN_DIV_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(749, ZEND_ASSIGN_DIV_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(755, ZEND_ASSIGN_DIV_SPEC_UNUSED_CV_OBJ) \
-       _(756, ZEND_ASSIGN_DIV_SPEC_CV_CONST) \
-       _(757, ZEND_ASSIGN_DIV_SPEC_CV_CONST_DIM) \
-       _(758, ZEND_ASSIGN_DIV_SPEC_CV_CONST_OBJ) \
-       _(759, ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR) \
-       _(760, ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_DIM) \
-       _(761, ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_OBJ) \
-       _(762, ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR) \
-       _(763, ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_DIM) \
-       _(764, ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_OBJ) \
-       _(766, ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_DIM) \
-       _(768, ZEND_ASSIGN_DIV_SPEC_CV_CV) \
-       _(769, ZEND_ASSIGN_DIV_SPEC_CV_CV_DIM) \
-       _(770, ZEND_ASSIGN_DIV_SPEC_CV_CV_OBJ) \
-       _(801, ZEND_ASSIGN_MOD_SPEC_VAR_CONST) \
-       _(802, ZEND_ASSIGN_MOD_SPEC_VAR_CONST_DIM) \
-       _(803, ZEND_ASSIGN_MOD_SPEC_VAR_CONST_OBJ) \
-       _(804, ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR) \
-       _(805, ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_DIM) \
-       _(806, ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_OBJ) \
-       _(807, ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR) \
-       _(808, ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_DIM) \
-       _(809, ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_OBJ) \
-       _(811, ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_DIM) \
-       _(813, ZEND_ASSIGN_MOD_SPEC_VAR_CV) \
-       _(814, ZEND_ASSIGN_MOD_SPEC_VAR_CV_DIM) \
-       _(815, ZEND_ASSIGN_MOD_SPEC_VAR_CV_OBJ) \
-       _(818, ZEND_ASSIGN_MOD_SPEC_UNUSED_CONST_OBJ) \
-       _(821, ZEND_ASSIGN_MOD_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(824, ZEND_ASSIGN_MOD_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(830, ZEND_ASSIGN_MOD_SPEC_UNUSED_CV_OBJ) \
-       _(831, ZEND_ASSIGN_MOD_SPEC_CV_CONST) \
-       _(832, ZEND_ASSIGN_MOD_SPEC_CV_CONST_DIM) \
-       _(833, ZEND_ASSIGN_MOD_SPEC_CV_CONST_OBJ) \
-       _(834, ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR) \
-       _(835, ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_DIM) \
-       _(836, ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_OBJ) \
-       _(837, ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR) \
-       _(838, ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_DIM) \
-       _(839, ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_OBJ) \
-       _(841, ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_DIM) \
-       _(843, ZEND_ASSIGN_MOD_SPEC_CV_CV) \
-       _(844, ZEND_ASSIGN_MOD_SPEC_CV_CV_DIM) \
-       _(845, ZEND_ASSIGN_MOD_SPEC_CV_CV_OBJ) \
-       _(876, ZEND_ASSIGN_SL_SPEC_VAR_CONST) \
-       _(877, ZEND_ASSIGN_SL_SPEC_VAR_CONST_DIM) \
-       _(878, ZEND_ASSIGN_SL_SPEC_VAR_CONST_OBJ) \
-       _(879, ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR) \
-       _(880, ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_DIM) \
-       _(881, ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_OBJ) \
-       _(882, ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR) \
-       _(883, ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_DIM) \
-       _(884, ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_OBJ) \
-       _(886, ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_DIM) \
-       _(888, ZEND_ASSIGN_SL_SPEC_VAR_CV) \
-       _(889, ZEND_ASSIGN_SL_SPEC_VAR_CV_DIM) \
-       _(890, ZEND_ASSIGN_SL_SPEC_VAR_CV_OBJ) \
-       _(893, ZEND_ASSIGN_SL_SPEC_UNUSED_CONST_OBJ) \
-       _(896, ZEND_ASSIGN_SL_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(899, ZEND_ASSIGN_SL_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(905, ZEND_ASSIGN_SL_SPEC_UNUSED_CV_OBJ) \
-       _(906, ZEND_ASSIGN_SL_SPEC_CV_CONST) \
-       _(907, ZEND_ASSIGN_SL_SPEC_CV_CONST_DIM) \
-       _(908, ZEND_ASSIGN_SL_SPEC_CV_CONST_OBJ) \
-       _(909, ZEND_ASSIGN_SL_SPEC_CV_TMPVAR) \
-       _(910, ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_DIM) \
-       _(911, ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_OBJ) \
-       _(912, ZEND_ASSIGN_SL_SPEC_CV_TMPVAR) \
-       _(913, ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_DIM) \
-       _(914, ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_OBJ) \
-       _(916, ZEND_ASSIGN_SL_SPEC_CV_UNUSED_DIM) \
-       _(918, ZEND_ASSIGN_SL_SPEC_CV_CV) \
-       _(919, ZEND_ASSIGN_SL_SPEC_CV_CV_DIM) \
-       _(920, ZEND_ASSIGN_SL_SPEC_CV_CV_OBJ) \
-       _(951, ZEND_ASSIGN_SR_SPEC_VAR_CONST) \
-       _(952, ZEND_ASSIGN_SR_SPEC_VAR_CONST_DIM) \
-       _(953, ZEND_ASSIGN_SR_SPEC_VAR_CONST_OBJ) \
-       _(954, ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR) \
-       _(955, ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_DIM) \
-       _(956, ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_OBJ) \
-       _(957, ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR) \
-       _(958, ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_DIM) \
-       _(959, ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_OBJ) \
-       _(961, ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_DIM) \
-       _(963, ZEND_ASSIGN_SR_SPEC_VAR_CV) \
-       _(964, ZEND_ASSIGN_SR_SPEC_VAR_CV_DIM) \
-       _(965, ZEND_ASSIGN_SR_SPEC_VAR_CV_OBJ) \
-       _(968, ZEND_ASSIGN_SR_SPEC_UNUSED_CONST_OBJ) \
-       _(971, ZEND_ASSIGN_SR_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(974, ZEND_ASSIGN_SR_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(980, ZEND_ASSIGN_SR_SPEC_UNUSED_CV_OBJ) \
-       _(981, ZEND_ASSIGN_SR_SPEC_CV_CONST) \
-       _(982, ZEND_ASSIGN_SR_SPEC_CV_CONST_DIM) \
-       _(983, ZEND_ASSIGN_SR_SPEC_CV_CONST_OBJ) \
-       _(984, ZEND_ASSIGN_SR_SPEC_CV_TMPVAR) \
-       _(985, ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_DIM) \
-       _(986, ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_OBJ) \
-       _(987, ZEND_ASSIGN_SR_SPEC_CV_TMPVAR) \
-       _(988, ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_DIM) \
-       _(989, ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_OBJ) \
-       _(991, ZEND_ASSIGN_SR_SPEC_CV_UNUSED_DIM) \
-       _(993, ZEND_ASSIGN_SR_SPEC_CV_CV) \
-       _(994, ZEND_ASSIGN_SR_SPEC_CV_CV_DIM) \
-       _(995, ZEND_ASSIGN_SR_SPEC_CV_CV_OBJ) \
-       _(1026, ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST) \
-       _(1027, ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_DIM) \
-       _(1028, ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_OBJ) \
-       _(1029, ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR) \
-       _(1030, ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_DIM) \
-       _(1031, ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_OBJ) \
-       _(1032, ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR) \
-       _(1033, ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_DIM) \
-       _(1034, ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_OBJ) \
-       _(1036, ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_DIM) \
-       _(1038, ZEND_ASSIGN_CONCAT_SPEC_VAR_CV) \
-       _(1039, ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_DIM) \
-       _(1040, ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_OBJ) \
-       _(1043, ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CONST_OBJ) \
-       _(1046, ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(1049, ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(1055, ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CV_OBJ) \
-       _(1056, ZEND_ASSIGN_CONCAT_SPEC_CV_CONST) \
-       _(1057, ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_DIM) \
-       _(1058, ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_OBJ) \
-       _(1059, ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR) \
-       _(1060, ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_DIM) \
-       _(1061, ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_OBJ) \
-       _(1062, ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR) \
-       _(1063, ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_DIM) \
-       _(1064, ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_OBJ) \
-       _(1066, ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_DIM) \
-       _(1068, ZEND_ASSIGN_CONCAT_SPEC_CV_CV) \
-       _(1069, ZEND_ASSIGN_CONCAT_SPEC_CV_CV_DIM) \
-       _(1070, ZEND_ASSIGN_CONCAT_SPEC_CV_CV_OBJ) \
-       _(1101, ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST) \
-       _(1102, ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_DIM) \
-       _(1103, ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_OBJ) \
-       _(1104, ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR) \
-       _(1105, ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_DIM) \
-       _(1106, ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_OBJ) \
-       _(1107, ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR) \
-       _(1108, ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_DIM) \
-       _(1109, ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_OBJ) \
-       _(1111, ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_DIM) \
-       _(1113, ZEND_ASSIGN_BW_OR_SPEC_VAR_CV) \
-       _(1114, ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_DIM) \
-       _(1115, ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_OBJ) \
-       _(1118, ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CONST_OBJ) \
-       _(1121, ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(1124, ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(1130, ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CV_OBJ) \
-       _(1131, ZEND_ASSIGN_BW_OR_SPEC_CV_CONST) \
-       _(1132, ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_DIM) \
-       _(1133, ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_OBJ) \
-       _(1134, ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR) \
-       _(1135, ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_DIM) \
-       _(1136, ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_OBJ) \
-       _(1137, ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR) \
-       _(1138, ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_DIM) \
-       _(1139, ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_OBJ) \
-       _(1141, ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_DIM) \
-       _(1143, ZEND_ASSIGN_BW_OR_SPEC_CV_CV) \
-       _(1144, ZEND_ASSIGN_BW_OR_SPEC_CV_CV_DIM) \
-       _(1145, ZEND_ASSIGN_BW_OR_SPEC_CV_CV_OBJ) \
-       _(1176, ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST) \
-       _(1177, ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_DIM) \
-       _(1178, ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_OBJ) \
-       _(1179, ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR) \
-       _(1180, ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_DIM) \
-       _(1181, ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_OBJ) \
-       _(1182, ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR) \
-       _(1183, ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_DIM) \
-       _(1184, ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_OBJ) \
-       _(1186, ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_DIM) \
-       _(1188, ZEND_ASSIGN_BW_AND_SPEC_VAR_CV) \
-       _(1189, ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_DIM) \
-       _(1190, ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_OBJ) \
-       _(1193, ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CONST_OBJ) \
-       _(1196, ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(1199, ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(1205, ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CV_OBJ) \
-       _(1206, ZEND_ASSIGN_BW_AND_SPEC_CV_CONST) \
-       _(1207, ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_DIM) \
-       _(1208, ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_OBJ) \
-       _(1209, ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR) \
-       _(1210, ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_DIM) \
-       _(1211, ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_OBJ) \
-       _(1212, ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR) \
-       _(1213, ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_DIM) \
-       _(1214, ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_OBJ) \
-       _(1216, ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_DIM) \
-       _(1218, ZEND_ASSIGN_BW_AND_SPEC_CV_CV) \
-       _(1219, ZEND_ASSIGN_BW_AND_SPEC_CV_CV_DIM) \
-       _(1220, ZEND_ASSIGN_BW_AND_SPEC_CV_CV_OBJ) \
-       _(1251, ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST) \
-       _(1252, ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_DIM) \
-       _(1253, ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_OBJ) \
-       _(1254, ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR) \
-       _(1255, ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_DIM) \
-       _(1256, ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_OBJ) \
-       _(1257, ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR) \
-       _(1258, ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_DIM) \
-       _(1259, ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_OBJ) \
-       _(1261, ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_DIM) \
-       _(1263, ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV) \
-       _(1264, ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_DIM) \
-       _(1265, ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_OBJ) \
-       _(1268, ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CONST_OBJ) \
-       _(1271, ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(1274, ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(1280, ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CV_OBJ) \
-       _(1281, ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST) \
-       _(1282, ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_DIM) \
-       _(1283, ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_OBJ) \
-       _(1284, ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR) \
-       _(1285, ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_DIM) \
-       _(1286, ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_OBJ) \
-       _(1287, ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR) \
-       _(1288, ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_DIM) \
-       _(1289, ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_OBJ) \
-       _(1291, ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_DIM) \
-       _(1293, ZEND_ASSIGN_BW_XOR_SPEC_CV_CV) \
-       _(1294, ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_DIM) \
-       _(1295, ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_OBJ) \
-       _(1300, ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED) \
-       _(1301, ZEND_PRE_INC_SPEC_VAR_RETVAL_USED) \
-       _(1304, ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED) \
-       _(1305, ZEND_PRE_INC_SPEC_CV_RETVAL_USED) \
-       _(1310, ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED) \
-       _(1311, ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED) \
-       _(1314, ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED) \
-       _(1315, ZEND_PRE_DEC_SPEC_CV_RETVAL_USED) \
-       _(1318, ZEND_POST_INC_SPEC_VAR) \
-       _(1320, ZEND_POST_INC_SPEC_CV) \
-       _(1323, ZEND_POST_DEC_SPEC_VAR) \
-       _(1325, ZEND_POST_DEC_SPEC_CV) \
-       _(1346, ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED) \
-       _(1347, ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED) \
-       _(1348, ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED) \
-       _(1349, ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED) \
-       _(1350, ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED) \
-       _(1351, ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED) \
-       _(1354, ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED) \
-       _(1355, ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED) \
-       _(1366, ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED) \
-       _(1367, ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED) \
-       _(1368, ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED) \
-       _(1369, ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED) \
-       _(1370, ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED) \
-       _(1371, ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED) \
-       _(1374, ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED) \
-       _(1375, ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED) \
-       _(1388, ZEND_ASSIGN_REF_SPEC_VAR_VAR) \
-       _(1390, ZEND_ASSIGN_REF_SPEC_VAR_CV) \
-       _(1398, ZEND_ASSIGN_REF_SPEC_CV_VAR) \
-       _(1400, ZEND_ASSIGN_REF_SPEC_CV_CV) \
-       _(1401, ZEND_ECHO_SPEC_CONST) \
-       _(1402, ZEND_ECHO_SPEC_TMPVAR) \
-       _(1403, ZEND_ECHO_SPEC_TMPVAR) \
-       _(1405, ZEND_ECHO_SPEC_CV) \
-       _(1406, ZEND_GENERATOR_CREATE_SPEC) \
-       _(1407, ZEND_JMP_SPEC) \
-       _(1408, ZEND_JMPZ_SPEC_CONST) \
-       _(1409, ZEND_JMPZ_SPEC_TMPVAR) \
-       _(1410, ZEND_JMPZ_SPEC_TMPVAR) \
-       _(1412, ZEND_JMPZ_SPEC_CV) \
-       _(1413, ZEND_JMPNZ_SPEC_CONST) \
-       _(1414, ZEND_JMPNZ_SPEC_TMPVAR) \
-       _(1415, ZEND_JMPNZ_SPEC_TMPVAR) \
-       _(1417, ZEND_JMPNZ_SPEC_CV) \
-       _(1418, ZEND_JMPZNZ_SPEC_CONST) \
-       _(1419, ZEND_JMPZNZ_SPEC_TMPVAR) \
-       _(1420, ZEND_JMPZNZ_SPEC_TMPVAR) \
-       _(1422, ZEND_JMPZNZ_SPEC_CV) \
-       _(1423, ZEND_JMPZ_EX_SPEC_CONST) \
-       _(1424, ZEND_JMPZ_EX_SPEC_TMPVAR) \
-       _(1425, ZEND_JMPZ_EX_SPEC_TMPVAR) \
-       _(1427, ZEND_JMPZ_EX_SPEC_CV) \
-       _(1428, ZEND_JMPNZ_EX_SPEC_CONST) \
-       _(1429, ZEND_JMPNZ_EX_SPEC_TMPVAR) \
-       _(1430, ZEND_JMPNZ_EX_SPEC_TMPVAR) \
-       _(1432, ZEND_JMPNZ_EX_SPEC_CV) \
-       _(1433, ZEND_CASE_SPEC_TMPVAR_CONST) \
-       _(1434, ZEND_CASE_SPEC_TMPVAR_TMPVAR) \
-       _(1435, ZEND_CASE_SPEC_TMPVAR_TMPVAR) \
-       _(1437, ZEND_CASE_SPEC_TMPVAR_CV) \
-       _(1438, ZEND_CHECK_VAR_SPEC_CV_UNUSED) \
-       _(1439, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR) \
-       _(1440, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_QUICK) \
-       _(1443, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \
-       _(1445, ZEND_MAKE_REF_SPEC_CV_UNUSED) \
-       _(1446, ZEND_BOOL_SPEC_CONST) \
-       _(1447, ZEND_BOOL_SPEC_TMPVAR) \
-       _(1448, ZEND_BOOL_SPEC_TMPVAR) \
-       _(1450, ZEND_BOOL_SPEC_CV) \
-       _(1451, ZEND_FAST_CONCAT_SPEC_CONST_CONST) \
-       _(1452, ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR) \
-       _(1453, ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR) \
-       _(1455, ZEND_FAST_CONCAT_SPEC_CONST_CV) \
-       _(1456, ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST) \
-       _(1457, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \
-       _(1458, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \
-       _(1460, ZEND_FAST_CONCAT_SPEC_TMPVAR_CV) \
-       _(1461, ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST) \
-       _(1462, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \
-       _(1463, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \
-       _(1465, ZEND_FAST_CONCAT_SPEC_TMPVAR_CV) \
-       _(1471, ZEND_FAST_CONCAT_SPEC_CV_CONST) \
-       _(1472, ZEND_FAST_CONCAT_SPEC_CV_TMPVAR) \
-       _(1473, ZEND_FAST_CONCAT_SPEC_CV_TMPVAR) \
-       _(1475, ZEND_FAST_CONCAT_SPEC_CV_CV) \
-       _(1476, ZEND_ROPE_INIT_SPEC_UNUSED_CONST) \
-       _(1477, ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR) \
-       _(1478, ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR) \
-       _(1480, ZEND_ROPE_INIT_SPEC_UNUSED_CV) \
-       _(1481, ZEND_ROPE_ADD_SPEC_TMP_CONST) \
-       _(1482, ZEND_ROPE_ADD_SPEC_TMP_TMPVAR) \
-       _(1483, ZEND_ROPE_ADD_SPEC_TMP_TMPVAR) \
-       _(1485, ZEND_ROPE_ADD_SPEC_TMP_CV) \
-       _(1486, ZEND_ROPE_END_SPEC_TMP_CONST) \
-       _(1487, ZEND_ROPE_END_SPEC_TMP_TMPVAR) \
-       _(1488, ZEND_ROPE_END_SPEC_TMP_TMPVAR) \
-       _(1490, ZEND_ROPE_END_SPEC_TMP_CV) \
-       _(1491, ZEND_BEGIN_SILENCE_SPEC) \
-       _(1492, ZEND_END_SILENCE_SPEC_TMP) \
-       _(1493, ZEND_INIT_FCALL_BY_NAME_SPEC_CONST) \
-       _(1494, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED) \
-       _(1495, ZEND_DO_FCALL_SPEC_RETVAL_USED) \
-       _(1496, ZEND_INIT_FCALL_SPEC_CONST) \
-       _(1497, ZEND_RETURN_SPEC_CONST) \
-       _(1498, ZEND_RETURN_SPEC_TMP) \
-       _(1499, ZEND_RETURN_SPEC_VAR) \
-       _(1501, ZEND_RETURN_SPEC_CV) \
-       _(1502, ZEND_RECV_SPEC_UNUSED) \
-       _(1503, ZEND_RECV_INIT_SPEC_CONST) \
-       _(1504, ZEND_SEND_VAL_SPEC_CONST) \
-       _(1505, ZEND_SEND_VAL_SPEC_TMPVAR) \
-       _(1506, ZEND_SEND_VAL_SPEC_TMPVAR) \
-       _(1513, ZEND_SEND_VAR_EX_SPEC_VAR) \
-       _(1514, ZEND_SEND_VAR_EX_SPEC_VAR_QUICK) \
-       _(1517, ZEND_SEND_VAR_EX_SPEC_CV) \
-       _(1518, ZEND_SEND_VAR_EX_SPEC_CV_QUICK) \
-       _(1521, ZEND_SEND_REF_SPEC_VAR) \
-       _(1523, ZEND_SEND_REF_SPEC_CV) \
-       _(1524, ZEND_NEW_SPEC_CONST_UNUSED) \
-       _(1526, ZEND_NEW_SPEC_VAR_UNUSED) \
-       _(1527, ZEND_NEW_SPEC_UNUSED_UNUSED) \
-       _(1529, ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST) \
-       _(1530, ZEND_FREE_SPEC_TMPVAR) \
-       _(1531, ZEND_INIT_ARRAY_SPEC_CONST_CONST) \
-       _(1532, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \
-       _(1533, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \
-       _(1534, ZEND_INIT_ARRAY_SPEC_CONST_UNUSED) \
-       _(1535, ZEND_INIT_ARRAY_SPEC_CONST_CV) \
-       _(1536, ZEND_INIT_ARRAY_SPEC_TMP_CONST) \
-       _(1537, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \
-       _(1538, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \
-       _(1539, ZEND_INIT_ARRAY_SPEC_TMP_UNUSED) \
-       _(1540, ZEND_INIT_ARRAY_SPEC_TMP_CV) \
-       _(1541, ZEND_INIT_ARRAY_SPEC_VAR_CONST) \
-       _(1542, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \
-       _(1543, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \
-       _(1544, ZEND_INIT_ARRAY_SPEC_VAR_UNUSED) \
-       _(1545, ZEND_INIT_ARRAY_SPEC_VAR_CV) \
-       _(1551, ZEND_INIT_ARRAY_SPEC_CV_CONST) \
-       _(1552, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \
-       _(1553, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \
-       _(1554, ZEND_INIT_ARRAY_SPEC_CV_UNUSED) \
-       _(1555, ZEND_INIT_ARRAY_SPEC_CV_CV) \
-       _(1556, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST) \
-       _(1557, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \
-       _(1558, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \
-       _(1559, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED) \
-       _(1560, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV) \
-       _(1561, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST) \
-       _(1562, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \
-       _(1563, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \
-       _(1564, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED) \
-       _(1565, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV) \
-       _(1566, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST) \
-       _(1567, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \
-       _(1568, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \
-       _(1569, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED) \
-       _(1570, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV) \
-       _(1576, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST) \
-       _(1577, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \
-       _(1578, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \
-       _(1579, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED) \
-       _(1580, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV) \
-       _(1581, ZEND_INCLUDE_OR_EVAL_SPEC_CONST) \
-       _(1582, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \
-       _(1583, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \
-       _(1585, ZEND_INCLUDE_OR_EVAL_SPEC_CV) \
-       _(1586, ZEND_UNSET_VAR_SPEC_CONST_UNUSED) \
-       _(1587, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \
-       _(1588, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \
-       _(1590, ZEND_UNSET_VAR_SPEC_CV_UNUSED) \
-       _(1601, ZEND_UNSET_DIM_SPEC_VAR_CONST) \
-       _(1602, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \
-       _(1603, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \
-       _(1605, ZEND_UNSET_DIM_SPEC_VAR_CV) \
-       _(1611, ZEND_UNSET_DIM_SPEC_CV_CONST) \
-       _(1612, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \
-       _(1613, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \
-       _(1615, ZEND_UNSET_DIM_SPEC_CV_CV) \
-       _(1626, ZEND_UNSET_OBJ_SPEC_VAR_CONST) \
-       _(1627, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \
-       _(1628, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \
-       _(1630, ZEND_UNSET_OBJ_SPEC_VAR_CV) \
-       _(1631, ZEND_UNSET_OBJ_SPEC_UNUSED_CONST) \
-       _(1632, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \
-       _(1633, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \
-       _(1635, ZEND_UNSET_OBJ_SPEC_UNUSED_CV) \
-       _(1636, ZEND_UNSET_OBJ_SPEC_CV_CONST) \
-       _(1637, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \
-       _(1638, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \
-       _(1640, ZEND_UNSET_OBJ_SPEC_CV_CV) \
-       _(1641, ZEND_FE_RESET_R_SPEC_CONST) \
-       _(1642, ZEND_FE_RESET_R_SPEC_TMP) \
-       _(1643, ZEND_FE_RESET_R_SPEC_VAR) \
-       _(1645, ZEND_FE_RESET_R_SPEC_CV) \
-       _(1646, ZEND_FE_FETCH_R_SPEC_VAR) \
-       _(1647, ZEND_EXIT_SPEC_CONST) \
-       _(1648, ZEND_EXIT_SPEC_TMPVAR) \
-       _(1649, ZEND_EXIT_SPEC_TMPVAR) \
-       _(1650, ZEND_EXIT_SPEC_UNUSED) \
-       _(1651, ZEND_EXIT_SPEC_CV) \
-       _(1652, ZEND_FETCH_R_SPEC_CONST_UNUSED) \
-       _(1653, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \
-       _(1654, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \
-       _(1656, ZEND_FETCH_R_SPEC_CV_UNUSED) \
-       _(1657, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \
-       _(1658, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \
-       _(1659, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \
-       _(1661, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \
-       _(1662, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \
-       _(1663, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \
-       _(1664, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \
-       _(1666, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \
-       _(1667, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \
-       _(1668, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \
-       _(1669, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \
-       _(1671, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \
-       _(1677, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \
-       _(1678, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \
-       _(1679, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \
-       _(1681, ZEND_FETCH_DIM_R_SPEC_CV_CV) \
-       _(1682, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \
-       _(1683, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \
-       _(1684, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \
-       _(1686, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \
-       _(1687, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \
-       _(1688, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \
-       _(1689, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \
-       _(1691, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \
-       _(1692, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \
-       _(1693, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \
-       _(1694, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \
-       _(1696, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \
-       _(1697, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \
-       _(1698, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \
-       _(1699, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \
-       _(1701, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \
-       _(1702, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \
-       _(1703, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \
-       _(1704, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \
-       _(1706, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \
-       _(1707, ZEND_FETCH_W_SPEC_CONST_UNUSED) \
-       _(1708, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \
-       _(1709, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \
-       _(1711, ZEND_FETCH_W_SPEC_CV_UNUSED) \
-       _(1722, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \
-       _(1723, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \
-       _(1724, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \
-       _(1725, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED) \
-       _(1726, ZEND_FETCH_DIM_W_SPEC_VAR_CV) \
-       _(1732, ZEND_FETCH_DIM_W_SPEC_CV_CONST) \
-       _(1733, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \
-       _(1734, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \
-       _(1735, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED) \
-       _(1736, ZEND_FETCH_DIM_W_SPEC_CV_CV) \
-       _(1747, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST) \
-       _(1748, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \
-       _(1749, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \
-       _(1751, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \
-       _(1752, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \
-       _(1753, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \
-       _(1754, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \
-       _(1756, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \
-       _(1757, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \
-       _(1758, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \
-       _(1759, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \
-       _(1761, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \
-       _(1762, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \
-       _(1763, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \
-       _(1764, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \
-       _(1766, ZEND_FETCH_RW_SPEC_CV_UNUSED) \
-       _(1777, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \
-       _(1778, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \
-       _(1779, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \
-       _(1780, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED) \
-       _(1781, ZEND_FETCH_DIM_RW_SPEC_VAR_CV) \
-       _(1787, ZEND_FETCH_DIM_RW_SPEC_CV_CONST) \
-       _(1788, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \
-       _(1789, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \
-       _(1790, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED) \
-       _(1791, ZEND_FETCH_DIM_RW_SPEC_CV_CV) \
-       _(1802, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST) \
-       _(1803, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \
-       _(1804, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \
-       _(1806, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \
-       _(1807, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \
-       _(1808, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \
-       _(1809, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \
-       _(1811, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \
-       _(1812, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \
-       _(1813, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \
-       _(1814, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \
-       _(1816, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \
-       _(1817, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \
-       _(1818, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \
-       _(1819, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \
-       _(1821, ZEND_FETCH_IS_SPEC_CV_UNUSED) \
-       _(1822, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \
-       _(1823, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \
-       _(1824, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \
-       _(1826, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \
-       _(1827, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \
-       _(1828, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \
-       _(1829, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \
-       _(1831, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \
-       _(1832, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \
-       _(1833, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \
-       _(1834, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \
-       _(1836, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \
-       _(1842, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \
-       _(1843, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \
-       _(1844, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \
-       _(1846, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \
-       _(1847, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \
-       _(1848, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \
-       _(1849, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \
-       _(1851, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \
-       _(1852, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \
-       _(1853, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \
-       _(1854, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \
-       _(1856, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \
-       _(1857, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \
-       _(1858, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \
-       _(1859, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \
-       _(1861, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \
-       _(1862, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \
-       _(1863, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \
-       _(1864, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \
-       _(1866, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \
-       _(1867, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \
-       _(1868, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \
-       _(1869, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \
-       _(1871, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \
-       _(1872, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \
-       _(1873, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \
-       _(1874, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \
-       _(1876, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED) \
-       _(1877, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST) \
-       _(1878, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \
-       _(1879, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \
-       _(1880, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED) \
-       _(1881, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV) \
-       _(1882, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) \
-       _(1883, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \
-       _(1884, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \
-       _(1885, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) \
-       _(1886, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) \
-       _(1887, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST) \
-       _(1888, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \
-       _(1889, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \
-       _(1890, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED) \
-       _(1891, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV) \
-       _(1897, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST) \
-       _(1898, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \
-       _(1899, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \
-       _(1900, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED) \
-       _(1901, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV) \
-       _(1902, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST) \
-       _(1903, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \
-       _(1904, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \
-       _(1906, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV) \
-       _(1907, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) \
-       _(1908, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \
-       _(1909, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \
-       _(1911, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) \
-       _(1912, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST) \
-       _(1913, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \
-       _(1914, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \
-       _(1916, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV) \
-       _(1917, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST) \
-       _(1918, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \
-       _(1919, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \
-       _(1921, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV) \
-       _(1922, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST) \
-       _(1923, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \
-       _(1924, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \
-       _(1926, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \
-       _(1927, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \
-       _(1928, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \
-       _(1929, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \
-       _(1931, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \
-       _(1942, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \
-       _(1943, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \
-       _(1944, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \
-       _(1946, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \
-       _(1952, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \
-       _(1953, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \
-       _(1954, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \
-       _(1956, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \
-       _(1967, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \
-       _(1968, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \
-       _(1969, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \
-       _(1971, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \
-       _(1972, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \
-       _(1973, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \
-       _(1974, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \
-       _(1976, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \
-       _(1977, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \
-       _(1978, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \
-       _(1979, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \
-       _(1981, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \
-       _(1982, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \
-       _(1983, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \
-       _(1984, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \
-       _(1986, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \
-       _(1987, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \
-       _(1988, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
-       _(1989, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
-       _(1991, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \
-       _(1992, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \
-       _(1993, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
-       _(1994, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
-       _(1996, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \
-       _(2002, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \
-       _(2003, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
-       _(2004, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
-       _(2006, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \
-       _(2007, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) \
-       _(2008, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED) \
-       _(2009, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_QUICK) \
-       _(2010, ZEND_EXT_STMT_SPEC) \
-       _(2011, ZEND_EXT_FCALL_BEGIN_SPEC) \
-       _(2012, ZEND_EXT_FCALL_END_SPEC) \
-       _(2013, ZEND_EXT_NOP_SPEC) \
-       _(2014, ZEND_TICKS_SPEC) \
-       _(2015, ZEND_SEND_VAR_NO_REF_SPEC_VAR) \
-       _(2016, ZEND_CATCH_SPEC_CONST) \
-       _(2017, ZEND_THROW_SPEC_CONST) \
-       _(2018, ZEND_THROW_SPEC_TMP) \
-       _(2019, ZEND_THROW_SPEC_VAR) \
-       _(2021, ZEND_THROW_SPEC_CV) \
-       _(2022, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \
-       _(2023, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \
-       _(2024, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \
-       _(2025, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \
-       _(2026, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \
-       _(2027, ZEND_CLONE_SPEC_CONST) \
-       _(2028, ZEND_CLONE_SPEC_TMPVAR) \
-       _(2029, ZEND_CLONE_SPEC_TMPVAR) \
-       _(2030, ZEND_CLONE_SPEC_UNUSED) \
-       _(2031, ZEND_CLONE_SPEC_CV) \
-       _(2032, ZEND_RETURN_BY_REF_SPEC_CONST) \
-       _(2033, ZEND_RETURN_BY_REF_SPEC_TMP) \
-       _(2034, ZEND_RETURN_BY_REF_SPEC_VAR) \
-       _(2036, ZEND_RETURN_BY_REF_SPEC_CV) \
-       _(2037, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) \
-       _(2038, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \
-       _(2039, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \
-       _(2041, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \
-       _(2042, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \
-       _(2043, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \
-       _(2044, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \
-       _(2046, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \
-       _(2047, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \
-       _(2048, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \
-       _(2049, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \
-       _(2051, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \
-       _(2052, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \
-       _(2053, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \
-       _(2054, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \
-       _(2056, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \
-       _(2057, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \
-       _(2058, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \
-       _(2059, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \
-       _(2061, ZEND_INIT_METHOD_CALL_SPEC_CV_CV) \
-       _(2062, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) \
-       _(2063, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \
-       _(2064, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \
-       _(2065, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) \
-       _(2066, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) \
-       _(2072, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) \
-       _(2073, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \
-       _(2074, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \
-       _(2075, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) \
-       _(2076, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) \
-       _(2077, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) \
-       _(2078, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \
-       _(2079, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \
-       _(2080, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) \
-       _(2081, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) \
-       _(2087, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) \
-       _(2088, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \
-       _(2089, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \
-       _(2091, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED) \
-       _(2092, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST) \
-       _(2093, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \
-       _(2094, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \
-       _(2096, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \
-       _(2097, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \
-       _(2098, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \
-       _(2099, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \
-       _(2101, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \
-       _(2102, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \
-       _(2103, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \
-       _(2104, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \
-       _(2106, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \
-       _(2112, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \
-       _(2113, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \
-       _(2114, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \
-       _(2116, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV) \
-       _(2117, ZEND_SEND_VAL_EX_SPEC_CONST) \
-       _(2118, ZEND_SEND_VAL_EX_SPEC_CONST_QUICK) \
-       _(2119, ZEND_SEND_VAL_EX_SPEC_TMP) \
-       _(2120, ZEND_SEND_VAL_EX_SPEC_TMP_QUICK) \
-       _(2129, ZEND_SEND_VAR_SPEC_VAR) \
-       _(2131, ZEND_SEND_VAR_SPEC_CV) \
-       _(2132, ZEND_INIT_USER_CALL_SPEC_CONST_CONST) \
-       _(2133, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \
-       _(2134, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \
-       _(2136, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \
-       _(2137, ZEND_SEND_ARRAY_SPEC) \
-       _(2138, ZEND_SEND_USER_SPEC_CONST) \
-       _(2139, ZEND_SEND_USER_SPEC_TMP) \
-       _(2140, ZEND_SEND_USER_SPEC_VAR) \
-       _(2142, ZEND_SEND_USER_SPEC_CV) \
-       _(2143, ZEND_STRLEN_SPEC_CONST) \
-       _(2144, ZEND_STRLEN_SPEC_TMPVAR) \
-       _(2145, ZEND_STRLEN_SPEC_TMPVAR) \
-       _(2147, ZEND_STRLEN_SPEC_CV) \
-       _(2148, ZEND_DEFINED_SPEC_CONST) \
-       _(2149, ZEND_TYPE_CHECK_SPEC_CONST) \
-       _(2150, ZEND_TYPE_CHECK_SPEC_TMPVAR) \
-       _(2151, ZEND_TYPE_CHECK_SPEC_TMPVAR) \
-       _(2153, ZEND_TYPE_CHECK_SPEC_CV) \
-       _(2154, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \
-       _(2155, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \
-       _(2156, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \
-       _(2157, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \
-       _(2158, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \
-       _(2159, ZEND_FE_RESET_RW_SPEC_CONST) \
-       _(2160, ZEND_FE_RESET_RW_SPEC_TMP) \
-       _(2161, ZEND_FE_RESET_RW_SPEC_VAR) \
-       _(2163, ZEND_FE_RESET_RW_SPEC_CV) \
-       _(2164, ZEND_FE_FETCH_RW_SPEC_VAR) \
-       _(2165, ZEND_FE_FREE_SPEC_TMPVAR) \
-       _(2166, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \
-       _(2167, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \
-       _(2168, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \
-       _(2170, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \
-       _(2171, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \
-       _(2172, ZEND_DO_ICALL_SPEC_RETVAL_USED) \
-       _(2173, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \
-       _(2174, ZEND_DO_UCALL_SPEC_RETVAL_USED) \
-       _(2175, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \
-       _(2176, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \
-       _(2187, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \
-       _(2188, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \
-       _(2189, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \
-       _(2191, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \
-       _(2192, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \
-       _(2193, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \
-       _(2194, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \
-       _(2196, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \
-       _(2197, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \
-       _(2198, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \
-       _(2199, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \
-       _(2201, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \
-       _(2212, ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST) \
-       _(2213, ZEND_PRE_DEC_OBJ_SPEC_VAR_TMPVAR) \
-       _(2214, ZEND_PRE_DEC_OBJ_SPEC_VAR_TMPVAR) \
-       _(2216, ZEND_PRE_DEC_OBJ_SPEC_VAR_CV) \
-       _(2217, ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST) \
-       _(2218, ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMPVAR) \
-       _(2219, ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMPVAR) \
-       _(2221, ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV) \
-       _(2222, ZEND_PRE_DEC_OBJ_SPEC_CV_CONST) \
-       _(2223, ZEND_PRE_DEC_OBJ_SPEC_CV_TMPVAR) \
-       _(2224, ZEND_PRE_DEC_OBJ_SPEC_CV_TMPVAR) \
-       _(2226, ZEND_PRE_DEC_OBJ_SPEC_CV_CV) \
-       _(2237, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \
-       _(2238, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \
-       _(2239, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \
-       _(2241, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \
-       _(2242, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \
-       _(2243, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \
-       _(2244, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \
-       _(2246, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \
-       _(2247, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \
-       _(2248, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \
-       _(2249, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \
-       _(2251, ZEND_POST_INC_OBJ_SPEC_CV_CV) \
-       _(2262, ZEND_POST_DEC_OBJ_SPEC_VAR_CONST) \
-       _(2263, ZEND_POST_DEC_OBJ_SPEC_VAR_TMPVAR) \
-       _(2264, ZEND_POST_DEC_OBJ_SPEC_VAR_TMPVAR) \
-       _(2266, ZEND_POST_DEC_OBJ_SPEC_VAR_CV) \
-       _(2267, ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST) \
-       _(2268, ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMPVAR) \
-       _(2269, ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMPVAR) \
-       _(2271, ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV) \
-       _(2272, ZEND_POST_DEC_OBJ_SPEC_CV_CONST) \
-       _(2273, ZEND_POST_DEC_OBJ_SPEC_CV_TMPVAR) \
-       _(2274, ZEND_POST_DEC_OBJ_SPEC_CV_TMPVAR) \
-       _(2276, ZEND_POST_DEC_OBJ_SPEC_CV_CV) \
-       _(2327, ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST) \
-       _(2328, ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP) \
-       _(2329, ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR) \
-       _(2331, ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV) \
-       _(2332, ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST) \
-       _(2333, ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP) \
-       _(2334, ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR) \
-       _(2336, ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV) \
-       _(2337, ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST) \
-       _(2338, ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP) \
-       _(2339, ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR) \
-       _(2341, ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV) \
-       _(2347, ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST) \
-       _(2348, ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP) \
-       _(2349, ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR) \
-       _(2351, ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV) \
-       _(2352, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST) \
-       _(2353, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP) \
-       _(2354, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR) \
-       _(2356, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV) \
-       _(2357, ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST) \
-       _(2358, ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP) \
-       _(2359, ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) \
-       _(2361, ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV) \
-       _(2362, ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST) \
-       _(2363, ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP) \
-       _(2364, ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) \
-       _(2366, ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV) \
-       _(2372, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST) \
-       _(2373, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP) \
-       _(2374, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR) \
-       _(2376, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV) \
-       _(2377, ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST) \
-       _(2378, ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP) \
-       _(2379, ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR) \
-       _(2381, ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV) \
-       _(2382, ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST) \
-       _(2383, ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP) \
-       _(2384, ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR) \
-       _(2386, ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV) \
-       _(2387, ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST) \
-       _(2388, ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP) \
-       _(2389, ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR) \
-       _(2391, ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV) \
-       _(2397, ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST) \
-       _(2398, ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP) \
-       _(2399, ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR) \
-       _(2401, ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV) \
-       _(2408, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \
-       _(2410, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \
-       _(2411, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \
-       _(2413, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \
-       _(2415, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \
-       _(2416, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \
-       _(2423, ZEND_INSTANCEOF_SPEC_CV_CONST) \
-       _(2425, ZEND_INSTANCEOF_SPEC_CV_VAR) \
-       _(2426, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \
-       _(2428, ZEND_DECLARE_CLASS_SPEC_CONST) \
-       _(2429, ZEND_DECLARE_INHERITED_CLASS_SPEC_CONST_CONST) \
-       _(2430, ZEND_DECLARE_FUNCTION_SPEC) \
-       _(2431, ZEND_YIELD_FROM_SPEC_CONST) \
-       _(2432, ZEND_YIELD_FROM_SPEC_TMP) \
-       _(2433, ZEND_YIELD_FROM_SPEC_VAR) \
-       _(2435, ZEND_YIELD_FROM_SPEC_CV) \
-       _(2436, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \
-       _(2437, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_CONST_CONST) \
-       _(2488, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST) \
-       _(2489, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP) \
-       _(2490, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR) \
-       _(2492, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV) \
-       _(2493, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST) \
-       _(2494, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP) \
-       _(2495, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR) \
-       _(2497, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV) \
-       _(2498, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST) \
-       _(2499, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP) \
-       _(2500, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR) \
-       _(2502, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV) \
-       _(2503, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST) \
-       _(2504, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP) \
-       _(2505, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR) \
-       _(2507, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV) \
-       _(2508, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST) \
-       _(2509, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP) \
-       _(2510, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR) \
-       _(2512, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV) \
-       _(2538, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST) \
-       _(2539, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP) \
-       _(2540, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR) \
-       _(2542, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV) \
-       _(2543, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST) \
-       _(2544, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP) \
-       _(2545, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR) \
-       _(2547, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV) \
-       _(2548, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST) \
-       _(2549, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP) \
-       _(2550, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR) \
-       _(2552, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV) \
-       _(2553, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST) \
-       _(2554, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP) \
-       _(2555, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR) \
-       _(2557, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV) \
-       _(2558, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST) \
-       _(2559, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP) \
-       _(2560, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR) \
-       _(2562, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV) \
-       _(2563, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \
-       _(2564, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \
-       _(2565, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \
-       _(2567, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \
-       _(2568, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \
-       _(2569, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
-       _(2570, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
-       _(2572, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \
-       _(2573, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \
-       _(2574, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
-       _(2575, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
-       _(2577, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \
-       _(2578, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \
-       _(2579, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \
-       _(2580, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \
-       _(2582, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \
-       _(2583, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \
-       _(2584, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \
-       _(2585, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \
-       _(2587, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \
-       _(2588, ZEND_HANDLE_EXCEPTION_SPEC) \
-       _(2589, ZEND_USER_OPCODE_SPEC) \
-       _(2590, ZEND_ASSERT_CHECK_SPEC) \
-       _(2591, ZEND_JMP_SET_SPEC_CONST) \
-       _(2592, ZEND_JMP_SET_SPEC_TMP) \
-       _(2593, ZEND_JMP_SET_SPEC_VAR) \
-       _(2595, ZEND_JMP_SET_SPEC_CV) \
-       _(2596, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) \
-       _(2597, ZEND_SEPARATE_SPEC_VAR_UNUSED) \
-       _(2598, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \
-       _(2599, ZEND_CALL_TRAMPOLINE_SPEC) \
-       _(2600, ZEND_DISCARD_EXCEPTION_SPEC) \
-       _(2601, ZEND_YIELD_SPEC_CONST_CONST) \
-       _(2602, ZEND_YIELD_SPEC_CONST_TMP) \
-       _(2603, ZEND_YIELD_SPEC_CONST_VAR) \
-       _(2604, ZEND_YIELD_SPEC_CONST_UNUSED) \
-       _(2605, ZEND_YIELD_SPEC_CONST_CV) \
-       _(2606, ZEND_YIELD_SPEC_TMP_CONST) \
-       _(2607, ZEND_YIELD_SPEC_TMP_TMP) \
-       _(2608, ZEND_YIELD_SPEC_TMP_VAR) \
-       _(2609, ZEND_YIELD_SPEC_TMP_UNUSED) \
-       _(2610, ZEND_YIELD_SPEC_TMP_CV) \
-       _(2611, ZEND_YIELD_SPEC_VAR_CONST) \
-       _(2612, ZEND_YIELD_SPEC_VAR_TMP) \
-       _(2613, ZEND_YIELD_SPEC_VAR_VAR) \
-       _(2614, ZEND_YIELD_SPEC_VAR_UNUSED) \
-       _(2615, ZEND_YIELD_SPEC_VAR_CV) \
-       _(2616, ZEND_YIELD_SPEC_UNUSED_CONST) \
-       _(2617, ZEND_YIELD_SPEC_UNUSED_TMP) \
-       _(2618, ZEND_YIELD_SPEC_UNUSED_VAR) \
-       _(2619, ZEND_YIELD_SPEC_UNUSED_UNUSED) \
-       _(2620, ZEND_YIELD_SPEC_UNUSED_CV) \
-       _(2621, ZEND_YIELD_SPEC_CV_CONST) \
-       _(2622, ZEND_YIELD_SPEC_CV_TMP) \
-       _(2623, ZEND_YIELD_SPEC_CV_VAR) \
-       _(2624, ZEND_YIELD_SPEC_CV_UNUSED) \
-       _(2625, ZEND_YIELD_SPEC_CV_CV) \
-       _(2626, ZEND_GENERATOR_RETURN_SPEC_CONST) \
-       _(2627, ZEND_GENERATOR_RETURN_SPEC_TMP) \
-       _(2628, ZEND_GENERATOR_RETURN_SPEC_VAR) \
-       _(2630, ZEND_GENERATOR_RETURN_SPEC_CV) \
-       _(2631, ZEND_FAST_CALL_SPEC) \
-       _(2632, ZEND_FAST_RET_SPEC) \
-       _(2633, ZEND_RECV_VARIADIC_SPEC_UNUSED) \
-       _(2634, ZEND_SEND_UNPACK_SPEC) \
-       _(2635, ZEND_POW_SPEC_CONST_CONST) \
-       _(2636, ZEND_POW_SPEC_CONST_TMPVAR) \
-       _(2637, ZEND_POW_SPEC_CONST_TMPVAR) \
-       _(2639, ZEND_POW_SPEC_CONST_CV) \
-       _(2640, ZEND_POW_SPEC_TMPVAR_CONST) \
-       _(2641, ZEND_POW_SPEC_TMPVAR_TMPVAR) \
-       _(2642, ZEND_POW_SPEC_TMPVAR_TMPVAR) \
-       _(2644, ZEND_POW_SPEC_TMPVAR_CV) \
-       _(2645, ZEND_POW_SPEC_TMPVAR_CONST) \
-       _(2646, ZEND_POW_SPEC_TMPVAR_TMPVAR) \
-       _(2647, ZEND_POW_SPEC_TMPVAR_TMPVAR) \
-       _(2649, ZEND_POW_SPEC_TMPVAR_CV) \
-       _(2655, ZEND_POW_SPEC_CV_CONST) \
-       _(2656, ZEND_POW_SPEC_CV_TMPVAR) \
-       _(2657, ZEND_POW_SPEC_CV_TMPVAR) \
-       _(2659, ZEND_POW_SPEC_CV_CV) \
-       _(2690, ZEND_ASSIGN_POW_SPEC_VAR_CONST) \
-       _(2691, ZEND_ASSIGN_POW_SPEC_VAR_CONST_DIM) \
-       _(2692, ZEND_ASSIGN_POW_SPEC_VAR_CONST_OBJ) \
-       _(2693, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR) \
-       _(2694, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM) \
-       _(2695, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ) \
-       _(2696, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR) \
-       _(2697, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM) \
-       _(2698, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ) \
-       _(2700, ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_DIM) \
-       _(2702, ZEND_ASSIGN_POW_SPEC_VAR_CV) \
-       _(2703, ZEND_ASSIGN_POW_SPEC_VAR_CV_DIM) \
-       _(2704, ZEND_ASSIGN_POW_SPEC_VAR_CV_OBJ) \
-       _(2707, ZEND_ASSIGN_POW_SPEC_UNUSED_CONST_OBJ) \
-       _(2710, ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(2713, ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ) \
-       _(2719, ZEND_ASSIGN_POW_SPEC_UNUSED_CV_OBJ) \
-       _(2720, ZEND_ASSIGN_POW_SPEC_CV_CONST) \
-       _(2721, ZEND_ASSIGN_POW_SPEC_CV_CONST_DIM) \
-       _(2722, ZEND_ASSIGN_POW_SPEC_CV_CONST_OBJ) \
-       _(2723, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR) \
-       _(2724, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM) \
-       _(2725, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ) \
-       _(2726, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR) \
-       _(2727, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM) \
-       _(2728, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ) \
-       _(2730, ZEND_ASSIGN_POW_SPEC_CV_UNUSED_DIM) \
-       _(2732, ZEND_ASSIGN_POW_SPEC_CV_CV) \
-       _(2733, ZEND_ASSIGN_POW_SPEC_CV_CV_DIM) \
-       _(2734, ZEND_ASSIGN_POW_SPEC_CV_CV_OBJ) \
-       _(2735, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \
-       _(2736, ZEND_COALESCE_SPEC_CONST) \
-       _(2737, ZEND_COALESCE_SPEC_TMPVAR) \
-       _(2738, ZEND_COALESCE_SPEC_TMPVAR) \
-       _(2740, ZEND_COALESCE_SPEC_CV) \
-       _(2741, ZEND_SPACESHIP_SPEC_CONST_CONST) \
-       _(2742, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \
-       _(2743, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \
-       _(2745, ZEND_SPACESHIP_SPEC_CONST_CV) \
-       _(2746, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \
-       _(2747, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
-       _(2748, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
-       _(2750, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \
-       _(2751, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \
-       _(2752, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
-       _(2753, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
-       _(2755, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \
-       _(2761, ZEND_SPACESHIP_SPEC_CV_CONST) \
-       _(2762, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \
-       _(2763, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \
-       _(2765, ZEND_SPACESHIP_SPEC_CV_CV) \
-       _(2766, ZEND_DECLARE_ANON_CLASS_SPEC) \
-       _(2767, ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_CONST_CONST) \
-       _(2768, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_CONST) \
-       _(2770, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_VAR) \
-       _(2771, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_UNUSED) \
-       _(2773, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST) \
-       _(2775, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR) \
-       _(2776, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_UNUSED) \
-       _(2778, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST) \
-       _(2780, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR) \
-       _(2781, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_UNUSED) \
-       _(2788, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_CONST) \
-       _(2790, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_VAR) \
-       _(2791, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_UNUSED) \
-       _(2793, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_CONST) \
-       _(2795, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_VAR) \
-       _(2796, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_UNUSED) \
-       _(2798, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_CONST) \
-       _(2800, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_VAR) \
-       _(2801, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_UNUSED) \
-       _(2803, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_CONST) \
-       _(2805, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_VAR) \
-       _(2806, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_UNUSED) \
-       _(2813, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_CONST) \
-       _(2815, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_VAR) \
-       _(2816, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_UNUSED) \
-       _(2818, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_CONST) \
-       _(2820, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_VAR) \
-       _(2821, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_UNUSED) \
-       _(2823, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_CONST) \
-       _(2825, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_VAR) \
-       _(2826, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_UNUSED) \
-       _(2828, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_CONST) \
-       _(2830, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_VAR) \
-       _(2831, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_UNUSED) \
-       _(2838, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_CONST) \
-       _(2840, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_VAR) \
-       _(2841, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_UNUSED) \
-       _(2843, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_CONST) \
-       _(2845, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_VAR) \
-       _(2846, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_UNUSED) \
-       _(2848, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_CONST) \
-       _(2850, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_VAR) \
-       _(2851, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_UNUSED) \
-       _(2853, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_CONST) \
-       _(2855, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_VAR) \
-       _(2856, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_UNUSED) \
-       _(2863, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_CONST) \
-       _(2865, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_VAR) \
-       _(2866, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_UNUSED) \
-       _(2868, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_CONST) \
-       _(2870, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_VAR) \
-       _(2871, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_UNUSED) \
-       _(2873, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_CONST) \
-       _(2875, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_VAR) \
-       _(2876, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_UNUSED) \
-       _(2878, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_CONST) \
-       _(2880, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_VAR) \
-       _(2881, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_UNUSED) \
-       _(2888, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_CONST) \
-       _(2890, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_VAR) \
-       _(2891, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_UNUSED) \
-       _(2893, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_CONST) \
-       _(2895, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_VAR) \
-       _(2896, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_UNUSED) \
-       _(2898, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_CONST) \
-       _(2900, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_VAR) \
-       _(2901, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_UNUSED) \
-       _(2903, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_CONST) \
-       _(2905, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_VAR) \
-       _(2906, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_UNUSED) \
-       _(2913, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_CONST) \
-       _(2915, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_VAR) \
-       _(2916, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_UNUSED) \
-       _(2918, ZEND_UNSET_STATIC_PROP_SPEC_CONST_CONST) \
-       _(2920, ZEND_UNSET_STATIC_PROP_SPEC_CONST_VAR) \
-       _(2921, ZEND_UNSET_STATIC_PROP_SPEC_CONST_UNUSED) \
-       _(2923, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_CONST) \
-       _(2925, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR) \
-       _(2926, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
-       _(2928, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_CONST) \
-       _(2930, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR) \
-       _(2931, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
-       _(2938, ZEND_UNSET_STATIC_PROP_SPEC_CV_CONST) \
-       _(2940, ZEND_UNSET_STATIC_PROP_SPEC_CV_VAR) \
-       _(2941, ZEND_UNSET_STATIC_PROP_SPEC_CV_UNUSED) \
-       _(2943, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_CONST) \
-       _(2945, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_VAR) \
-       _(2946, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_UNUSED) \
-       _(2948, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_CONST) \
-       _(2950, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_VAR) \
-       _(2951, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
-       _(2953, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_CONST) \
-       _(2955, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_VAR) \
-       _(2956, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
-       _(2963, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_CONST) \
-       _(2965, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_VAR) \
-       _(2966, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_UNUSED) \
-       _(2968, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \
-       _(2970, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \
-       _(2971, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \
-       _(2973, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \
-       _(2974, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \
-       _(2975, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \
-       _(2976, ZEND_SEND_FUNC_ARG_SPEC_VAR) \
-       _(2977, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \
-       _(2978, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \
-       _(2979, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
-       _(2980, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
-       _(2982, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
-       _(2983, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \
-       _(2984, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
-       _(2985, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
-       _(2987, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
-       _(2988, ZEND_IN_ARRAY_SPEC_CONST_CONST) \
-       _(2989, ZEND_IN_ARRAY_SPEC_TMP_CONST) \
-       _(2990, ZEND_IN_ARRAY_SPEC_VAR_CONST) \
-       _(2992, ZEND_IN_ARRAY_SPEC_CV_CONST) \
-       _(2993, ZEND_COUNT_SPEC_CONST_UNUSED) \
-       _(2994, ZEND_COUNT_SPEC_TMP_UNUSED) \
-       _(2995, ZEND_COUNT_SPEC_VAR_UNUSED) \
-       _(2997, ZEND_COUNT_SPEC_CV_UNUSED) \
-       _(2998, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \
-       _(2999, ZEND_GET_CLASS_SPEC_TMP_UNUSED) \
-       _(3000, ZEND_GET_CLASS_SPEC_VAR_UNUSED) \
-       _(3001, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \
-       _(3002, ZEND_GET_CLASS_SPEC_CV_UNUSED) \
-       _(3003, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \
-       _(3004, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \
-       _(3005, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \
-       _(3006, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \
-       _(3008, ZEND_GET_TYPE_SPEC_CV_UNUSED) \
-       _(3009, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \
-       _(3010, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \
-       _(3013, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \
-       _(3015, ZEND_UNSET_CV_SPEC_CV_UNUSED) \
-       _(3016, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \
-       _(3017, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \
-       _(3018, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \
-       _(3019, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \
-       _(3020, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \
-       _(3022, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \
-       _(3023, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \
-       _(3024, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \
-       _(3025, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \
-       _(3027, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \
-       _(3028, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \
-       _(3029, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
-       _(3030, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
-       _(3032, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \
-       _(3033, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \
-       _(3034, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
-       _(3035, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
-       _(3037, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \
-       _(3043, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \
-       _(3044, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \
-       _(3045, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \
-       _(3047, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \
-       _(3048, ZEND_JMP_FORWARD_SPEC) \
-       _(3054, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3055, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3056, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3058, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3059, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3060, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3061, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3063, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3069, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3070, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3071, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3073, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3079, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-       _(3080, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3081, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3083, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3084, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-       _(3085, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3086, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3088, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3094, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-       _(3095, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3096, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3098, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3104, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3105, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3106, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3108, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3109, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3110, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3111, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3113, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3119, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3120, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3121, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3123, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3125, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-       _(3126, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-       _(3128, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-       _(3129, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3130, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3131, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3133, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3134, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3135, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3136, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3138, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3144, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3145, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3146, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3148, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3150, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-       _(3151, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-       _(3153, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-       _(3154, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-       _(3155, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3156, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3158, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3159, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-       _(3160, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3161, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3163, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3169, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-       _(3170, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3171, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3173, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3175, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3176, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3178, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3179, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3180, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3181, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3183, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3184, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3185, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3186, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3188, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3194, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3195, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3196, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3198, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3204, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3205, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3206, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3208, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3209, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3210, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3211, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3213, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3219, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3220, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3221, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3223, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3229, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3230, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3231, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3233, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3234, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3235, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3236, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3238, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3244, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3245, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3246, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3248, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3254, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3255, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3256, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3258, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3259, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3260, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3261, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3263, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3269, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3270, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3271, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3273, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3289, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3290, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3291, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3292, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3293, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3294, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3295, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3296, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3297, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3301, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3302, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3303, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3304, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3305, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3306, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3307, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3308, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3309, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3310, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3311, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3312, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3316, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3317, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3318, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3334, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3335, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3336, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3337, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3338, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3339, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3340, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3341, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3342, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3346, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3347, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3348, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3364, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3365, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3366, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3367, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3368, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3369, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3370, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3371, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3372, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3376, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3377, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3378, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3379, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3380, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3381, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3382, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3383, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3384, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3385, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3386, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3387, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3391, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3392, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3393, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3409, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3410, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3411, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3412, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3413, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3414, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3415, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3416, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3417, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3421, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3422, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3423, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3439, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3440, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3441, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3442, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3443, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3444, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3445, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3446, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3447, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3451, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3452, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3453, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3454, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3455, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3456, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3457, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3458, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3459, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3460, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3461, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3462, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3466, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3467, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3468, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3484, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3485, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3486, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3487, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3488, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3489, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3490, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3491, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3492, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3496, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3497, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3498, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3514, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3515, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3516, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3517, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3518, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3519, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3520, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3521, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3522, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3526, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3527, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3528, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3529, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3530, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3531, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3532, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3533, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3534, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3535, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3536, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3537, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3541, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3542, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3543, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3559, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3560, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3561, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3562, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3563, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3564, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3565, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3566, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3567, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3571, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3572, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3573, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3577, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-       _(3578, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3579, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3580, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-       _(3581, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3582, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3586, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-       _(3587, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3588, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3589, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-       _(3590, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3591, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3592, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3593, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3594, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3595, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3596, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3597, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3601, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3602, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3603, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3604, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-       _(3605, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3606, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3607, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3608, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3609, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3610, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3611, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3612, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3616, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3617, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3618, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3634, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-       _(3635, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3636, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3637, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3638, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3639, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3640, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3641, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3642, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3646, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3647, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3648, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3652, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3653, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3654, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3655, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3656, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3657, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3661, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3662, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3663, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3664, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3665, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3666, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3667, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3668, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3669, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3670, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3671, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3672, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3676, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3677, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3678, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3679, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3680, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3681, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3682, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3683, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3684, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3685, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3686, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3687, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3691, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3692, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3693, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3709, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3710, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3711, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3712, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3713, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3714, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3715, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3716, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3717, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3721, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3722, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3723, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3727, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-       _(3728, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3729, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3730, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-       _(3731, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3732, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3736, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-       _(3737, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3738, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3739, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3740, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3741, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3742, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3743, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3744, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3745, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3746, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3747, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3751, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3752, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3753, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3754, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3755, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3756, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3757, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3758, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3759, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3760, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3761, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3762, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3766, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3767, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3768, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3784, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3785, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3786, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3787, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3788, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3789, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3790, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3791, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3792, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3796, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3797, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3798, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3802, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3803, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3804, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3805, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3806, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3807, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3811, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3812, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3813, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3814, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3815, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3816, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3817, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3818, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3819, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3820, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3821, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3822, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3826, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3827, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3828, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3829, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3830, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3831, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3832, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3833, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3834, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3835, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3836, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3837, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3841, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3842, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3843, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3859, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3860, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3861, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3862, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3863, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3864, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3865, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3866, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3867, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3871, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3872, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3873, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3874, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(3875, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \
-       _(3876, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(3877, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED) \
-       _(3878, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(3879, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \
-       _(3880, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(3881, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \
-       _(3882, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(3883, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED) \
-       _(3884, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(3885, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \
-       _(3886, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \
-       _(3887, ZEND_POST_INC_LONG_SPEC_TMPVARCV) \
-       _(3888, ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \
-       _(3889, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \
-       _(3890, ZEND_POST_DEC_LONG_SPEC_TMPVARCV) \
-       _(3891, ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \
-       _(3892, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \
-       _(3893, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-       _(3894, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-       _(3896, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-       _(3897, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \
-       _(3898, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-       _(3899, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-       _(3901, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-       _(3903, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-       _(3904, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-       _(3906, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-       _(3907, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
-       _(3908, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(3909, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(3911, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(3912, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
-       _(3913, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(3914, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(3916, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(3922, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \
-       _(3923, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-       _(3924, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-       _(3926, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-       _(3929, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \
-       _(3931, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \
-       _(3934, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \
-       _(3936, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \
-       _(3937, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \
-       _(3938, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \
-       _(3939, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \
-       _(3940, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \
-       _(3940+1, ZEND_NULL)
+       _(474, ZEND_ASSIGN_ADD_SPEC_CONST_CONST_STATIC_PROP) \
+       _(478, ZEND_ASSIGN_ADD_SPEC_CONST_TMPVAR_STATIC_PROP) \
+       _(482, ZEND_ASSIGN_ADD_SPEC_CONST_TMPVAR_STATIC_PROP) \
+       _(486, ZEND_ASSIGN_ADD_SPEC_CONST_UNUSED_STATIC_PROP) \
+       _(494, ZEND_ASSIGN_ADD_SPEC_TMP_CONST_STATIC_PROP) \
+       _(498, ZEND_ASSIGN_ADD_SPEC_TMP_TMPVAR_STATIC_PROP) \
+       _(502, ZEND_ASSIGN_ADD_SPEC_TMP_TMPVAR_STATIC_PROP) \
+       _(506, ZEND_ASSIGN_ADD_SPEC_TMP_UNUSED_STATIC_PROP) \
+       _(511, ZEND_ASSIGN_ADD_SPEC_VAR_CONST) \
+       _(512, ZEND_ASSIGN_ADD_SPEC_VAR_CONST_DIM) \
+       _(513, ZEND_ASSIGN_ADD_SPEC_VAR_CONST_OBJ) \
+       _(514, ZEND_ASSIGN_ADD_SPEC_VAR_CONST_STATIC_PROP) \
+       _(515, ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR) \
+       _(516, ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_DIM) \
+       _(517, ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_OBJ) \
+       _(518, ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_STATIC_PROP) \
+       _(519, ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR) \
+       _(520, ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_DIM) \
+       _(521, ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_OBJ) \
+       _(522, ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_STATIC_PROP) \
+       _(524, ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_DIM) \
+       _(526, ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_STATIC_PROP) \
+       _(527, ZEND_ASSIGN_ADD_SPEC_VAR_CV) \
+       _(528, ZEND_ASSIGN_ADD_SPEC_VAR_CV_DIM) \
+       _(529, ZEND_ASSIGN_ADD_SPEC_VAR_CV_OBJ) \
+       _(533, ZEND_ASSIGN_ADD_SPEC_UNUSED_CONST_OBJ) \
+       _(537, ZEND_ASSIGN_ADD_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(541, ZEND_ASSIGN_ADD_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(549, ZEND_ASSIGN_ADD_SPEC_UNUSED_CV_OBJ) \
+       _(551, ZEND_ASSIGN_ADD_SPEC_CV_CONST) \
+       _(552, ZEND_ASSIGN_ADD_SPEC_CV_CONST_DIM) \
+       _(553, ZEND_ASSIGN_ADD_SPEC_CV_CONST_OBJ) \
+       _(554, ZEND_ASSIGN_ADD_SPEC_CV_CONST_STATIC_PROP) \
+       _(555, ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR) \
+       _(556, ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_DIM) \
+       _(557, ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_OBJ) \
+       _(558, ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_STATIC_PROP) \
+       _(559, ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR) \
+       _(560, ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_DIM) \
+       _(561, ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_OBJ) \
+       _(562, ZEND_ASSIGN_ADD_SPEC_CV_TMPVAR_STATIC_PROP) \
+       _(564, ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_DIM) \
+       _(566, ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_STATIC_PROP) \
+       _(567, ZEND_ASSIGN_ADD_SPEC_CV_CV) \
+       _(568, ZEND_ASSIGN_ADD_SPEC_CV_CV_DIM) \
+       _(569, ZEND_ASSIGN_ADD_SPEC_CV_CV_OBJ) \
+       _(574, ZEND_ASSIGN_SUB_SPEC_CONST_CONST_STATIC_PROP) \
+       _(578, ZEND_ASSIGN_SUB_SPEC_CONST_TMPVAR_STATIC_PROP) \
+       _(582, ZEND_ASSIGN_SUB_SPEC_CONST_TMPVAR_STATIC_PROP) \
+       _(586, ZEND_ASSIGN_SUB_SPEC_CONST_UNUSED_STATIC_PROP) \
+       _(594, ZEND_ASSIGN_SUB_SPEC_TMP_CONST_STATIC_PROP) \
+       _(598, ZEND_ASSIGN_SUB_SPEC_TMP_TMPVAR_STATIC_PROP) \
+       _(602, ZEND_ASSIGN_SUB_SPEC_TMP_TMPVAR_STATIC_PROP) \
+       _(606, ZEND_ASSIGN_SUB_SPEC_TMP_UNUSED_STATIC_PROP) \
+       _(611, ZEND_ASSIGN_SUB_SPEC_VAR_CONST) \
+       _(612, ZEND_ASSIGN_SUB_SPEC_VAR_CONST_DIM) \
+       _(613, ZEND_ASSIGN_SUB_SPEC_VAR_CONST_OBJ) \
+       _(614, ZEND_ASSIGN_SUB_SPEC_VAR_CONST_STATIC_PROP) \
+       _(615, ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR) \
+       _(616, ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_DIM) \
+       _(617, ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_OBJ) \
+       _(618, ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_STATIC_PROP) \
+       _(619, ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR) \
+       _(620, ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_DIM) \
+       _(621, ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_OBJ) \
+       _(622, ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_STATIC_PROP) \
+       _(624, ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_DIM) \
+       _(626, ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_STATIC_PROP) \
+       _(627, ZEND_ASSIGN_SUB_SPEC_VAR_CV) \
+       _(628, ZEND_ASSIGN_SUB_SPEC_VAR_CV_DIM) \
+       _(629, ZEND_ASSIGN_SUB_SPEC_VAR_CV_OBJ) \
+       _(633, ZEND_ASSIGN_SUB_SPEC_UNUSED_CONST_OBJ) \
+       _(637, ZEND_ASSIGN_SUB_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(641, ZEND_ASSIGN_SUB_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(649, ZEND_ASSIGN_SUB_SPEC_UNUSED_CV_OBJ) \
+       _(651, ZEND_ASSIGN_SUB_SPEC_CV_CONST) \
+       _(652, ZEND_ASSIGN_SUB_SPEC_CV_CONST_DIM) \
+       _(653, ZEND_ASSIGN_SUB_SPEC_CV_CONST_OBJ) \
+       _(654, ZEND_ASSIGN_SUB_SPEC_CV_CONST_STATIC_PROP) \
+       _(655, ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR) \
+       _(656, ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_DIM) \
+       _(657, ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_OBJ) \
+       _(658, ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_STATIC_PROP) \
+       _(659, ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR) \
+       _(660, ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_DIM) \
+       _(661, ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_OBJ) \
+       _(662, ZEND_ASSIGN_SUB_SPEC_CV_TMPVAR_STATIC_PROP) \
+       _(664, ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_DIM) \
+       _(666, ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_STATIC_PROP) \
+       _(667, ZEND_ASSIGN_SUB_SPEC_CV_CV) \
+       _(668, ZEND_ASSIGN_SUB_SPEC_CV_CV_DIM) \
+       _(669, ZEND_ASSIGN_SUB_SPEC_CV_CV_OBJ) \
+       _(674, ZEND_ASSIGN_MUL_SPEC_CONST_CONST_STATIC_PROP) \
+       _(678, ZEND_ASSIGN_MUL_SPEC_CONST_TMPVAR_STATIC_PROP) \
+       _(682, ZEND_ASSIGN_MUL_SPEC_CONST_TMPVAR_STATIC_PROP) \
+       _(686, ZEND_ASSIGN_MUL_SPEC_CONST_UNUSED_STATIC_PROP) \
+       _(694, ZEND_ASSIGN_MUL_SPEC_TMP_CONST_STATIC_PROP) \
+       _(698, ZEND_ASSIGN_MUL_SPEC_TMP_TMPVAR_STATIC_PROP) \
+       _(702, ZEND_ASSIGN_MUL_SPEC_TMP_TMPVAR_STATIC_PROP) \
+       _(706, ZEND_ASSIGN_MUL_SPEC_TMP_UNUSED_STATIC_PROP) \
+       _(711, ZEND_ASSIGN_MUL_SPEC_VAR_CONST) \
+       _(712, ZEND_ASSIGN_MUL_SPEC_VAR_CONST_DIM) \
+       _(713, ZEND_ASSIGN_MUL_SPEC_VAR_CONST_OBJ) \
+       _(714, ZEND_ASSIGN_MUL_SPEC_VAR_CONST_STATIC_PROP) \
+       _(715, ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR) \
+       _(716, ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_DIM) \
+       _(717, ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_OBJ) \
+       _(718, ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_STATIC_PROP) \
+       _(719, ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR) \
+       _(720, ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_DIM) \
+       _(721, ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_OBJ) \
+       _(722, ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_STATIC_PROP) \
+       _(724, ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_DIM) \
+       _(726, ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_STATIC_PROP) \
+       _(727, ZEND_ASSIGN_MUL_SPEC_VAR_CV) \
+       _(728, ZEND_ASSIGN_MUL_SPEC_VAR_CV_DIM) \
+       _(729, ZEND_ASSIGN_MUL_SPEC_VAR_CV_OBJ) \
+       _(733, ZEND_ASSIGN_MUL_SPEC_UNUSED_CONST_OBJ) \
+       _(737, ZEND_ASSIGN_MUL_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(741, ZEND_ASSIGN_MUL_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(749, ZEND_ASSIGN_MUL_SPEC_UNUSED_CV_OBJ) \
+       _(751, ZEND_ASSIGN_MUL_SPEC_CV_CONST) \
+       _(752, ZEND_ASSIGN_MUL_SPEC_CV_CONST_DIM) \
+       _(753, ZEND_ASSIGN_MUL_SPEC_CV_CONST_OBJ) \
+       _(754, ZEND_ASSIGN_MUL_SPEC_CV_CONST_STATIC_PROP) \
+       _(755, ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR) \
+       _(756, ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_DIM) \
+       _(757, ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_OBJ) \
+       _(758, ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_STATIC_PROP) \
+       _(759, ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR) \
+       _(760, ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_DIM) \
+       _(761, ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_OBJ) \
+       _(762, ZEND_ASSIGN_MUL_SPEC_CV_TMPVAR_STATIC_PROP) \
+       _(764, ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_DIM) \
+       _(766, ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_STATIC_PROP) \
+       _(767, ZEND_ASSIGN_MUL_SPEC_CV_CV) \
+       _(768, ZEND_ASSIGN_MUL_SPEC_CV_CV_DIM) \
+       _(769, ZEND_ASSIGN_MUL_SPEC_CV_CV_OBJ) \
+       _(774, ZEND_ASSIGN_DIV_SPEC_CONST_CONST_STATIC_PROP) \
+       _(778, ZEND_ASSIGN_DIV_SPEC_CONST_TMPVAR_STATIC_PROP) \
+       _(782, ZEND_ASSIGN_DIV_SPEC_CONST_TMPVAR_STATIC_PROP) \
+       _(786, ZEND_ASSIGN_DIV_SPEC_CONST_UNUSED_STATIC_PROP) \
+       _(794, ZEND_ASSIGN_DIV_SPEC_TMP_CONST_STATIC_PROP) \
+       _(798, ZEND_ASSIGN_DIV_SPEC_TMP_TMPVAR_STATIC_PROP) \
+       _(802, ZEND_ASSIGN_DIV_SPEC_TMP_TMPVAR_STATIC_PROP) \
+       _(806, ZEND_ASSIGN_DIV_SPEC_TMP_UNUSED_STATIC_PROP) \
+       _(811, ZEND_ASSIGN_DIV_SPEC_VAR_CONST) \
+       _(812, ZEND_ASSIGN_DIV_SPEC_VAR_CONST_DIM) \
+       _(813, ZEND_ASSIGN_DIV_SPEC_VAR_CONST_OBJ) \
+       _(814, ZEND_ASSIGN_DIV_SPEC_VAR_CONST_STATIC_PROP) \
+       _(815, ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR) \
+       _(816, ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_DIM) \
+       _(817, ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_OBJ) \
+       _(818, ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_STATIC_PROP) \
+       _(819, ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR) \
+       _(820, ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_DIM) \
+       _(821, ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_OBJ) \
+       _(822, ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_STATIC_PROP) \
+       _(824, ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_DIM) \
+       _(826, ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_STATIC_PROP) \
+       _(827, ZEND_ASSIGN_DIV_SPEC_VAR_CV) \
+       _(828, ZEND_ASSIGN_DIV_SPEC_VAR_CV_DIM) \
+       _(829, ZEND_ASSIGN_DIV_SPEC_VAR_CV_OBJ) \
+       _(833, ZEND_ASSIGN_DIV_SPEC_UNUSED_CONST_OBJ) \
+       _(837, ZEND_ASSIGN_DIV_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(841, ZEND_ASSIGN_DIV_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(849, ZEND_ASSIGN_DIV_SPEC_UNUSED_CV_OBJ) \
+       _(851, ZEND_ASSIGN_DIV_SPEC_CV_CONST) \
+       _(852, ZEND_ASSIGN_DIV_SPEC_CV_CONST_DIM) \
+       _(853, ZEND_ASSIGN_DIV_SPEC_CV_CONST_OBJ) \
+       _(854, ZEND_ASSIGN_DIV_SPEC_CV_CONST_STATIC_PROP) \
+       _(855, ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR) \
+       _(856, ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_DIM) \
+       _(857, ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_OBJ) \
+       _(858, ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_STATIC_PROP) \
+       _(859, ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR) \
+       _(860, ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_DIM) \
+       _(861, ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_OBJ) \
+       _(862, ZEND_ASSIGN_DIV_SPEC_CV_TMPVAR_STATIC_PROP) \
+       _(864, ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_DIM) \
+       _(866, ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_STATIC_PROP) \
+       _(867, ZEND_ASSIGN_DIV_SPEC_CV_CV) \
+       _(868, ZEND_ASSIGN_DIV_SPEC_CV_CV_DIM) \
+       _(869, ZEND_ASSIGN_DIV_SPEC_CV_CV_OBJ) \
+       _(874, ZEND_ASSIGN_MOD_SPEC_CONST_CONST_STATIC_PROP) \
+       _(878, ZEND_ASSIGN_MOD_SPEC_CONST_TMPVAR_STATIC_PROP) \
+       _(882, ZEND_ASSIGN_MOD_SPEC_CONST_TMPVAR_STATIC_PROP) \
+       _(886, ZEND_ASSIGN_MOD_SPEC_CONST_UNUSED_STATIC_PROP) \
+       _(894, ZEND_ASSIGN_MOD_SPEC_TMP_CONST_STATIC_PROP) \
+       _(898, ZEND_ASSIGN_MOD_SPEC_TMP_TMPVAR_STATIC_PROP) \
+       _(902, ZEND_ASSIGN_MOD_SPEC_TMP_TMPVAR_STATIC_PROP) \
+       _(906, ZEND_ASSIGN_MOD_SPEC_TMP_UNUSED_STATIC_PROP) \
+       _(911, ZEND_ASSIGN_MOD_SPEC_VAR_CONST) \
+       _(912, ZEND_ASSIGN_MOD_SPEC_VAR_CONST_DIM) \
+       _(913, ZEND_ASSIGN_MOD_SPEC_VAR_CONST_OBJ) \
+       _(914, ZEND_ASSIGN_MOD_SPEC_VAR_CONST_STATIC_PROP) \
+       _(915, ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR) \
+       _(916, ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_DIM) \
+       _(917, ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_OBJ) \
+       _(918, ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_STATIC_PROP) \
+       _(919, ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR) \
+       _(920, ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_DIM) \
+       _(921, ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_OBJ) \
+       _(922, ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_STATIC_PROP) \
+       _(924, ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_DIM) \
+       _(926, ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_STATIC_PROP) \
+       _(927, ZEND_ASSIGN_MOD_SPEC_VAR_CV) \
+       _(928, ZEND_ASSIGN_MOD_SPEC_VAR_CV_DIM) \
+       _(929, ZEND_ASSIGN_MOD_SPEC_VAR_CV_OBJ) \
+       _(933, ZEND_ASSIGN_MOD_SPEC_UNUSED_CONST_OBJ) \
+       _(937, ZEND_ASSIGN_MOD_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(941, ZEND_ASSIGN_MOD_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(949, ZEND_ASSIGN_MOD_SPEC_UNUSED_CV_OBJ) \
+       _(951, ZEND_ASSIGN_MOD_SPEC_CV_CONST) \
+       _(952, ZEND_ASSIGN_MOD_SPEC_CV_CONST_DIM) \
+       _(953, ZEND_ASSIGN_MOD_SPEC_CV_CONST_OBJ) \
+       _(954, ZEND_ASSIGN_MOD_SPEC_CV_CONST_STATIC_PROP) \
+       _(955, ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR) \
+       _(956, ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_DIM) \
+       _(957, ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_OBJ) \
+       _(958, ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_STATIC_PROP) \
+       _(959, ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR) \
+       _(960, ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_DIM) \
+       _(961, ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_OBJ) \
+       _(962, ZEND_ASSIGN_MOD_SPEC_CV_TMPVAR_STATIC_PROP) \
+       _(964, ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_DIM) \
+       _(966, ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_STATIC_PROP) \
+       _(967, ZEND_ASSIGN_MOD_SPEC_CV_CV) \
+       _(968, ZEND_ASSIGN_MOD_SPEC_CV_CV_DIM) \
+       _(969, ZEND_ASSIGN_MOD_SPEC_CV_CV_OBJ) \
+       _(974, ZEND_ASSIGN_SL_SPEC_CONST_CONST_STATIC_PROP) \
+       _(978, ZEND_ASSIGN_SL_SPEC_CONST_TMPVAR_STATIC_PROP) \
+       _(982, ZEND_ASSIGN_SL_SPEC_CONST_TMPVAR_STATIC_PROP) \
+       _(986, ZEND_ASSIGN_SL_SPEC_CONST_UNUSED_STATIC_PROP) \
+       _(994, ZEND_ASSIGN_SL_SPEC_TMP_CONST_STATIC_PROP) \
+       _(998, ZEND_ASSIGN_SL_SPEC_TMP_TMPVAR_STATIC_PROP) \
+       _(1002, ZEND_ASSIGN_SL_SPEC_TMP_TMPVAR_STATIC_PROP) \
+       _(1006, ZEND_ASSIGN_SL_SPEC_TMP_UNUSED_STATIC_PROP) \
+       _(1011, ZEND_ASSIGN_SL_SPEC_VAR_CONST) \
+       _(1012, ZEND_ASSIGN_SL_SPEC_VAR_CONST_DIM) \
+       _(1013, ZEND_ASSIGN_SL_SPEC_VAR_CONST_OBJ) \
+       _(1014, ZEND_ASSIGN_SL_SPEC_VAR_CONST_STATIC_PROP) \
+       _(1015, ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR) \
+       _(1016, ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_DIM) \
+       _(1017, ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_OBJ) \
+       _(1018, ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_STATIC_PROP) \
+       _(1019, ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR) \
+       _(1020, ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_DIM) \
+       _(1021, ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_OBJ) \
+       _(1022, ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_STATIC_PROP) \
+       _(1024, ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_DIM) \
+       _(1026, ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_STATIC_PROP) \
+       _(1027, ZEND_ASSIGN_SL_SPEC_VAR_CV) \
+       _(1028, ZEND_ASSIGN_SL_SPEC_VAR_CV_DIM) \
+       _(1029, ZEND_ASSIGN_SL_SPEC_VAR_CV_OBJ) \
+       _(1033, ZEND_ASSIGN_SL_SPEC_UNUSED_CONST_OBJ) \
+       _(1037, ZEND_ASSIGN_SL_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(1041, ZEND_ASSIGN_SL_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(1049, ZEND_ASSIGN_SL_SPEC_UNUSED_CV_OBJ) \
+       _(1051, ZEND_ASSIGN_SL_SPEC_CV_CONST) \
+       _(1052, ZEND_ASSIGN_SL_SPEC_CV_CONST_DIM) \
+       _(1053, ZEND_ASSIGN_SL_SPEC_CV_CONST_OBJ) \
+       _(1054, ZEND_ASSIGN_SL_SPEC_CV_CONST_STATIC_PROP) \
+       _(1055, ZEND_ASSIGN_SL_SPEC_CV_TMPVAR) \
+       _(1056, ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_DIM) \
+       _(1057, ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_OBJ) \
+       _(1058, ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_STATIC_PROP) \
+       _(1059, ZEND_ASSIGN_SL_SPEC_CV_TMPVAR) \
+       _(1060, ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_DIM) \
+       _(1061, ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_OBJ) \
+       _(1062, ZEND_ASSIGN_SL_SPEC_CV_TMPVAR_STATIC_PROP) \
+       _(1064, ZEND_ASSIGN_SL_SPEC_CV_UNUSED_DIM) \
+       _(1066, ZEND_ASSIGN_SL_SPEC_CV_UNUSED_STATIC_PROP) \
+       _(1067, ZEND_ASSIGN_SL_SPEC_CV_CV) \
+       _(1068, ZEND_ASSIGN_SL_SPEC_CV_CV_DIM) \
+       _(1069, ZEND_ASSIGN_SL_SPEC_CV_CV_OBJ) \
+       _(1074, ZEND_ASSIGN_SR_SPEC_CONST_CONST_STATIC_PROP) \
+       _(1078, ZEND_ASSIGN_SR_SPEC_CONST_TMPVAR_STATIC_PROP) \
+       _(1082, ZEND_ASSIGN_SR_SPEC_CONST_TMPVAR_STATIC_PROP) \
+       _(1086, ZEND_ASSIGN_SR_SPEC_CONST_UNUSED_STATIC_PROP) \
+       _(1094, ZEND_ASSIGN_SR_SPEC_TMP_CONST_STATIC_PROP) \
+       _(1098, ZEND_ASSIGN_SR_SPEC_TMP_TMPVAR_STATIC_PROP) \
+       _(1102, ZEND_ASSIGN_SR_SPEC_TMP_TMPVAR_STATIC_PROP) \
+       _(1106, ZEND_ASSIGN_SR_SPEC_TMP_UNUSED_STATIC_PROP) \
+       _(1111, ZEND_ASSIGN_SR_SPEC_VAR_CONST) \
+       _(1112, ZEND_ASSIGN_SR_SPEC_VAR_CONST_DIM) \
+       _(1113, ZEND_ASSIGN_SR_SPEC_VAR_CONST_OBJ) \
+       _(1114, ZEND_ASSIGN_SR_SPEC_VAR_CONST_STATIC_PROP) \
+       _(1115, ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR) \
+       _(1116, ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_DIM) \
+       _(1117, ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_OBJ) \
+       _(1118, ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_STATIC_PROP) \
+       _(1119, ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR) \
+       _(1120, ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_DIM) \
+       _(1121, ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_OBJ) \
+       _(1122, ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_STATIC_PROP) \
+       _(1124, ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_DIM) \
+       _(1126, ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_STATIC_PROP) \
+       _(1127, ZEND_ASSIGN_SR_SPEC_VAR_CV) \
+       _(1128, ZEND_ASSIGN_SR_SPEC_VAR_CV_DIM) \
+       _(1129, ZEND_ASSIGN_SR_SPEC_VAR_CV_OBJ) \
+       _(1133, ZEND_ASSIGN_SR_SPEC_UNUSED_CONST_OBJ) \
+       _(1137, ZEND_ASSIGN_SR_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(1141, ZEND_ASSIGN_SR_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(1149, ZEND_ASSIGN_SR_SPEC_UNUSED_CV_OBJ) \
+       _(1151, ZEND_ASSIGN_SR_SPEC_CV_CONST) \
+       _(1152, ZEND_ASSIGN_SR_SPEC_CV_CONST_DIM) \
+       _(1153, ZEND_ASSIGN_SR_SPEC_CV_CONST_OBJ) \
+       _(1154, ZEND_ASSIGN_SR_SPEC_CV_CONST_STATIC_PROP) \
+       _(1155, ZEND_ASSIGN_SR_SPEC_CV_TMPVAR) \
+       _(1156, ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_DIM) \
+       _(1157, ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_OBJ) \
+       _(1158, ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_STATIC_PROP) \
+       _(1159, ZEND_ASSIGN_SR_SPEC_CV_TMPVAR) \
+       _(1160, ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_DIM) \
+       _(1161, ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_OBJ) \
+       _(1162, ZEND_ASSIGN_SR_SPEC_CV_TMPVAR_STATIC_PROP) \
+       _(1164, ZEND_ASSIGN_SR_SPEC_CV_UNUSED_DIM) \
+       _(1166, ZEND_ASSIGN_SR_SPEC_CV_UNUSED_STATIC_PROP) \
+       _(1167, ZEND_ASSIGN_SR_SPEC_CV_CV) \
+       _(1168, ZEND_ASSIGN_SR_SPEC_CV_CV_DIM) \
+       _(1169, ZEND_ASSIGN_SR_SPEC_CV_CV_OBJ) \
+       _(1174, ZEND_ASSIGN_CONCAT_SPEC_CONST_CONST_STATIC_PROP) \
+       _(1178, ZEND_ASSIGN_CONCAT_SPEC_CONST_TMPVAR_STATIC_PROP) \
+       _(1182, ZEND_ASSIGN_CONCAT_SPEC_CONST_TMPVAR_STATIC_PROP) \
+       _(1186, ZEND_ASSIGN_CONCAT_SPEC_CONST_UNUSED_STATIC_PROP) \
+       _(1194, ZEND_ASSIGN_CONCAT_SPEC_TMP_CONST_STATIC_PROP) \
+       _(1198, ZEND_ASSIGN_CONCAT_SPEC_TMP_TMPVAR_STATIC_PROP) \
+       _(1202, ZEND_ASSIGN_CONCAT_SPEC_TMP_TMPVAR_STATIC_PROP) \
+       _(1206, ZEND_ASSIGN_CONCAT_SPEC_TMP_UNUSED_STATIC_PROP) \
+       _(1211, ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST) \
+       _(1212, ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_DIM) \
+       _(1213, ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_OBJ) \
+       _(1214, ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_STATIC_PROP) \
+       _(1215, ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR) \
+       _(1216, ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_DIM) \
+       _(1217, ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_OBJ) \
+       _(1218, ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_STATIC_PROP) \
+       _(1219, ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR) \
+       _(1220, ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_DIM) \
+       _(1221, ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_OBJ) \
+       _(1222, ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_STATIC_PROP) \
+       _(1224, ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_DIM) \
+       _(1226, ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_STATIC_PROP) \
+       _(1227, ZEND_ASSIGN_CONCAT_SPEC_VAR_CV) \
+       _(1228, ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_DIM) \
+       _(1229, ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_OBJ) \
+       _(1233, ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CONST_OBJ) \
+       _(1237, ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(1241, ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(1249, ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CV_OBJ) \
+       _(1251, ZEND_ASSIGN_CONCAT_SPEC_CV_CONST) \
+       _(1252, ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_DIM) \
+       _(1253, ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_OBJ) \
+       _(1254, ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_STATIC_PROP) \
+       _(1255, ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR) \
+       _(1256, ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_DIM) \
+       _(1257, ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_OBJ) \
+       _(1258, ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_STATIC_PROP) \
+       _(1259, ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR) \
+       _(1260, ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_DIM) \
+       _(1261, ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_OBJ) \
+       _(1262, ZEND_ASSIGN_CONCAT_SPEC_CV_TMPVAR_STATIC_PROP) \
+       _(1264, ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_DIM) \
+       _(1266, ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_STATIC_PROP) \
+       _(1267, ZEND_ASSIGN_CONCAT_SPEC_CV_CV) \
+       _(1268, ZEND_ASSIGN_CONCAT_SPEC_CV_CV_DIM) \
+       _(1269, ZEND_ASSIGN_CONCAT_SPEC_CV_CV_OBJ) \
+       _(1274, ZEND_ASSIGN_BW_OR_SPEC_CONST_CONST_STATIC_PROP) \
+       _(1278, ZEND_ASSIGN_BW_OR_SPEC_CONST_TMPVAR_STATIC_PROP) \
+       _(1282, ZEND_ASSIGN_BW_OR_SPEC_CONST_TMPVAR_STATIC_PROP) \
+       _(1286, ZEND_ASSIGN_BW_OR_SPEC_CONST_UNUSED_STATIC_PROP) \
+       _(1294, ZEND_ASSIGN_BW_OR_SPEC_TMP_CONST_STATIC_PROP) \
+       _(1298, ZEND_ASSIGN_BW_OR_SPEC_TMP_TMPVAR_STATIC_PROP) \
+       _(1302, ZEND_ASSIGN_BW_OR_SPEC_TMP_TMPVAR_STATIC_PROP) \
+       _(1306, ZEND_ASSIGN_BW_OR_SPEC_TMP_UNUSED_STATIC_PROP) \
+       _(1311, ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST) \
+       _(1312, ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_DIM) \
+       _(1313, ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_OBJ) \
+       _(1314, ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_STATIC_PROP) \
+       _(1315, ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR) \
+       _(1316, ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_DIM) \
+       _(1317, ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_OBJ) \
+       _(1318, ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_STATIC_PROP) \
+       _(1319, ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR) \
+       _(1320, ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_DIM) \
+       _(1321, ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_OBJ) \
+       _(1322, ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_STATIC_PROP) \
+       _(1324, ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_DIM) \
+       _(1326, ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_STATIC_PROP) \
+       _(1327, ZEND_ASSIGN_BW_OR_SPEC_VAR_CV) \
+       _(1328, ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_DIM) \
+       _(1329, ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_OBJ) \
+       _(1333, ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CONST_OBJ) \
+       _(1337, ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(1341, ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(1349, ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CV_OBJ) \
+       _(1351, ZEND_ASSIGN_BW_OR_SPEC_CV_CONST) \
+       _(1352, ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_DIM) \
+       _(1353, ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_OBJ) \
+       _(1354, ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_STATIC_PROP) \
+       _(1355, ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR) \
+       _(1356, ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_DIM) \
+       _(1357, ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_OBJ) \
+       _(1358, ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_STATIC_PROP) \
+       _(1359, ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR) \
+       _(1360, ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_DIM) \
+       _(1361, ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_OBJ) \
+       _(1362, ZEND_ASSIGN_BW_OR_SPEC_CV_TMPVAR_STATIC_PROP) \
+       _(1364, ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_DIM) \
+       _(1366, ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_STATIC_PROP) \
+       _(1367, ZEND_ASSIGN_BW_OR_SPEC_CV_CV) \
+       _(1368, ZEND_ASSIGN_BW_OR_SPEC_CV_CV_DIM) \
+       _(1369, ZEND_ASSIGN_BW_OR_SPEC_CV_CV_OBJ) \
+       _(1374, ZEND_ASSIGN_BW_AND_SPEC_CONST_CONST_STATIC_PROP) \
+       _(1378, ZEND_ASSIGN_BW_AND_SPEC_CONST_TMPVAR_STATIC_PROP) \
+       _(1382, ZEND_ASSIGN_BW_AND_SPEC_CONST_TMPVAR_STATIC_PROP) \
+       _(1386, ZEND_ASSIGN_BW_AND_SPEC_CONST_UNUSED_STATIC_PROP) \
+       _(1394, ZEND_ASSIGN_BW_AND_SPEC_TMP_CONST_STATIC_PROP) \
+       _(1398, ZEND_ASSIGN_BW_AND_SPEC_TMP_TMPVAR_STATIC_PROP) \
+       _(1402, ZEND_ASSIGN_BW_AND_SPEC_TMP_TMPVAR_STATIC_PROP) \
+       _(1406, ZEND_ASSIGN_BW_AND_SPEC_TMP_UNUSED_STATIC_PROP) \
+       _(1411, ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST) \
+       _(1412, ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_DIM) \
+       _(1413, ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_OBJ) \
+       _(1414, ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_STATIC_PROP) \
+       _(1415, ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR) \
+       _(1416, ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_DIM) \
+       _(1417, ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_OBJ) \
+       _(1418, ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_STATIC_PROP) \
+       _(1419, ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR) \
+       _(1420, ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_DIM) \
+       _(1421, ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_OBJ) \
+       _(1422, ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_STATIC_PROP) \
+       _(1424, ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_DIM) \
+       _(1426, ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_STATIC_PROP) \
+       _(1427, ZEND_ASSIGN_BW_AND_SPEC_VAR_CV) \
+       _(1428, ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_DIM) \
+       _(1429, ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_OBJ) \
+       _(1433, ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CONST_OBJ) \
+       _(1437, ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(1441, ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(1449, ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CV_OBJ) \
+       _(1451, ZEND_ASSIGN_BW_AND_SPEC_CV_CONST) \
+       _(1452, ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_DIM) \
+       _(1453, ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_OBJ) \
+       _(1454, ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_STATIC_PROP) \
+       _(1455, ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR) \
+       _(1456, ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_DIM) \
+       _(1457, ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_OBJ) \
+       _(1458, ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_STATIC_PROP) \
+       _(1459, ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR) \
+       _(1460, ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_DIM) \
+       _(1461, ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_OBJ) \
+       _(1462, ZEND_ASSIGN_BW_AND_SPEC_CV_TMPVAR_STATIC_PROP) \
+       _(1464, ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_DIM) \
+       _(1466, ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_STATIC_PROP) \
+       _(1467, ZEND_ASSIGN_BW_AND_SPEC_CV_CV) \
+       _(1468, ZEND_ASSIGN_BW_AND_SPEC_CV_CV_DIM) \
+       _(1469, ZEND_ASSIGN_BW_AND_SPEC_CV_CV_OBJ) \
+       _(1474, ZEND_ASSIGN_BW_XOR_SPEC_CONST_CONST_STATIC_PROP) \
+       _(1478, ZEND_ASSIGN_BW_XOR_SPEC_CONST_TMPVAR_STATIC_PROP) \
+       _(1482, ZEND_ASSIGN_BW_XOR_SPEC_CONST_TMPVAR_STATIC_PROP) \
+       _(1486, ZEND_ASSIGN_BW_XOR_SPEC_CONST_UNUSED_STATIC_PROP) \
+       _(1494, ZEND_ASSIGN_BW_XOR_SPEC_TMP_CONST_STATIC_PROP) \
+       _(1498, ZEND_ASSIGN_BW_XOR_SPEC_TMP_TMPVAR_STATIC_PROP) \
+       _(1502, ZEND_ASSIGN_BW_XOR_SPEC_TMP_TMPVAR_STATIC_PROP) \
+       _(1506, ZEND_ASSIGN_BW_XOR_SPEC_TMP_UNUSED_STATIC_PROP) \
+       _(1511, ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST) \
+       _(1512, ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_DIM) \
+       _(1513, ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_OBJ) \
+       _(1514, ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_STATIC_PROP) \
+       _(1515, ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR) \
+       _(1516, ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_DIM) \
+       _(1517, ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_OBJ) \
+       _(1518, ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_STATIC_PROP) \
+       _(1519, ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR) \
+       _(1520, ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_DIM) \
+       _(1521, ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_OBJ) \
+       _(1522, ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_STATIC_PROP) \
+       _(1524, ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_DIM) \
+       _(1526, ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_STATIC_PROP) \
+       _(1527, ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV) \
+       _(1528, ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_DIM) \
+       _(1529, ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_OBJ) \
+       _(1533, ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CONST_OBJ) \
+       _(1537, ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(1541, ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(1549, ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CV_OBJ) \
+       _(1551, ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST) \
+       _(1552, ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_DIM) \
+       _(1553, ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_OBJ) \
+       _(1554, ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_STATIC_PROP) \
+       _(1555, ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR) \
+       _(1556, ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_DIM) \
+       _(1557, ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_OBJ) \
+       _(1558, ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_STATIC_PROP) \
+       _(1559, ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR) \
+       _(1560, ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_DIM) \
+       _(1561, ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_OBJ) \
+       _(1562, ZEND_ASSIGN_BW_XOR_SPEC_CV_TMPVAR_STATIC_PROP) \
+       _(1564, ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_DIM) \
+       _(1566, ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_STATIC_PROP) \
+       _(1567, ZEND_ASSIGN_BW_XOR_SPEC_CV_CV) \
+       _(1568, ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_DIM) \
+       _(1569, ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_OBJ) \
+       _(1575, ZEND_PRE_INC_SPEC_VAR_RETVAL_UNUSED) \
+       _(1576, ZEND_PRE_INC_SPEC_VAR_RETVAL_USED) \
+       _(1579, ZEND_PRE_INC_SPEC_CV_RETVAL_UNUSED) \
+       _(1580, ZEND_PRE_INC_SPEC_CV_RETVAL_USED) \
+       _(1585, ZEND_PRE_DEC_SPEC_VAR_RETVAL_UNUSED) \
+       _(1586, ZEND_PRE_DEC_SPEC_VAR_RETVAL_USED) \
+       _(1589, ZEND_PRE_DEC_SPEC_CV_RETVAL_UNUSED) \
+       _(1590, ZEND_PRE_DEC_SPEC_CV_RETVAL_USED) \
+       _(1593, ZEND_POST_INC_SPEC_VAR) \
+       _(1595, ZEND_POST_INC_SPEC_CV) \
+       _(1598, ZEND_POST_DEC_SPEC_VAR) \
+       _(1600, ZEND_POST_DEC_SPEC_CV) \
+       _(1621, ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_UNUSED) \
+       _(1622, ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED) \
+       _(1623, ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED) \
+       _(1624, ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED) \
+       _(1625, ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED) \
+       _(1626, ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED) \
+       _(1629, ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED) \
+       _(1630, ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_USED) \
+       _(1641, ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_UNUSED) \
+       _(1642, ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED) \
+       _(1643, ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED) \
+       _(1644, ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED) \
+       _(1645, ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED) \
+       _(1646, ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED) \
+       _(1649, ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED) \
+       _(1650, ZEND_ASSIGN_SPEC_CV_CV_RETVAL_USED) \
+       _(1663, ZEND_ASSIGN_REF_SPEC_VAR_VAR) \
+       _(1665, ZEND_ASSIGN_REF_SPEC_VAR_CV) \
+       _(1673, ZEND_ASSIGN_REF_SPEC_CV_VAR) \
+       _(1675, ZEND_ASSIGN_REF_SPEC_CV_CV) \
+       _(1676, ZEND_ECHO_SPEC_CONST) \
+       _(1677, ZEND_ECHO_SPEC_TMPVAR) \
+       _(1678, ZEND_ECHO_SPEC_TMPVAR) \
+       _(1680, ZEND_ECHO_SPEC_CV) \
+       _(1681, ZEND_GENERATOR_CREATE_SPEC) \
+       _(1682, ZEND_JMP_SPEC) \
+       _(1683, ZEND_JMPZ_SPEC_CONST) \
+       _(1684, ZEND_JMPZ_SPEC_TMPVAR) \
+       _(1685, ZEND_JMPZ_SPEC_TMPVAR) \
+       _(1687, ZEND_JMPZ_SPEC_CV) \
+       _(1688, ZEND_JMPNZ_SPEC_CONST) \
+       _(1689, ZEND_JMPNZ_SPEC_TMPVAR) \
+       _(1690, ZEND_JMPNZ_SPEC_TMPVAR) \
+       _(1692, ZEND_JMPNZ_SPEC_CV) \
+       _(1693, ZEND_JMPZNZ_SPEC_CONST) \
+       _(1694, ZEND_JMPZNZ_SPEC_TMPVAR) \
+       _(1695, ZEND_JMPZNZ_SPEC_TMPVAR) \
+       _(1697, ZEND_JMPZNZ_SPEC_CV) \
+       _(1698, ZEND_JMPZ_EX_SPEC_CONST) \
+       _(1699, ZEND_JMPZ_EX_SPEC_TMPVAR) \
+       _(1700, ZEND_JMPZ_EX_SPEC_TMPVAR) \
+       _(1702, ZEND_JMPZ_EX_SPEC_CV) \
+       _(1703, ZEND_JMPNZ_EX_SPEC_CONST) \
+       _(1704, ZEND_JMPNZ_EX_SPEC_TMPVAR) \
+       _(1705, ZEND_JMPNZ_EX_SPEC_TMPVAR) \
+       _(1707, ZEND_JMPNZ_EX_SPEC_CV) \
+       _(1708, ZEND_CASE_SPEC_TMPVAR_CONST) \
+       _(1709, ZEND_CASE_SPEC_TMPVAR_TMPVAR) \
+       _(1710, ZEND_CASE_SPEC_TMPVAR_TMPVAR) \
+       _(1712, ZEND_CASE_SPEC_TMPVAR_CV) \
+       _(1713, ZEND_CHECK_VAR_SPEC_CV_UNUSED) \
+       _(1714, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR) \
+       _(1715, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_QUICK) \
+       _(1718, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \
+       _(1720, ZEND_MAKE_REF_SPEC_CV_UNUSED) \
+       _(1721, ZEND_BOOL_SPEC_CONST) \
+       _(1722, ZEND_BOOL_SPEC_TMPVAR) \
+       _(1723, ZEND_BOOL_SPEC_TMPVAR) \
+       _(1725, ZEND_BOOL_SPEC_CV) \
+       _(1726, ZEND_FAST_CONCAT_SPEC_CONST_CONST) \
+       _(1727, ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR) \
+       _(1728, ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR) \
+       _(1730, ZEND_FAST_CONCAT_SPEC_CONST_CV) \
+       _(1731, ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST) \
+       _(1732, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \
+       _(1733, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \
+       _(1735, ZEND_FAST_CONCAT_SPEC_TMPVAR_CV) \
+       _(1736, ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST) \
+       _(1737, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \
+       _(1738, ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) \
+       _(1740, ZEND_FAST_CONCAT_SPEC_TMPVAR_CV) \
+       _(1746, ZEND_FAST_CONCAT_SPEC_CV_CONST) \
+       _(1747, ZEND_FAST_CONCAT_SPEC_CV_TMPVAR) \
+       _(1748, ZEND_FAST_CONCAT_SPEC_CV_TMPVAR) \
+       _(1750, ZEND_FAST_CONCAT_SPEC_CV_CV) \
+       _(1751, ZEND_ROPE_INIT_SPEC_UNUSED_CONST) \
+       _(1752, ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR) \
+       _(1753, ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR) \
+       _(1755, ZEND_ROPE_INIT_SPEC_UNUSED_CV) \
+       _(1756, ZEND_ROPE_ADD_SPEC_TMP_CONST) \
+       _(1757, ZEND_ROPE_ADD_SPEC_TMP_TMPVAR) \
+       _(1758, ZEND_ROPE_ADD_SPEC_TMP_TMPVAR) \
+       _(1760, ZEND_ROPE_ADD_SPEC_TMP_CV) \
+       _(1761, ZEND_ROPE_END_SPEC_TMP_CONST) \
+       _(1762, ZEND_ROPE_END_SPEC_TMP_TMPVAR) \
+       _(1763, ZEND_ROPE_END_SPEC_TMP_TMPVAR) \
+       _(1765, ZEND_ROPE_END_SPEC_TMP_CV) \
+       _(1766, ZEND_BEGIN_SILENCE_SPEC) \
+       _(1767, ZEND_END_SILENCE_SPEC_TMP) \
+       _(1768, ZEND_INIT_FCALL_BY_NAME_SPEC_CONST) \
+       _(1769, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED) \
+       _(1770, ZEND_DO_FCALL_SPEC_RETVAL_USED) \
+       _(1771, ZEND_INIT_FCALL_SPEC_CONST) \
+       _(1772, ZEND_RETURN_SPEC_CONST) \
+       _(1773, ZEND_RETURN_SPEC_TMP) \
+       _(1774, ZEND_RETURN_SPEC_VAR) \
+       _(1776, ZEND_RETURN_SPEC_CV) \
+       _(1777, ZEND_RECV_SPEC_UNUSED) \
+       _(1778, ZEND_RECV_INIT_SPEC_CONST) \
+       _(1779, ZEND_SEND_VAL_SPEC_CONST) \
+       _(1780, ZEND_SEND_VAL_SPEC_TMPVAR) \
+       _(1781, ZEND_SEND_VAL_SPEC_TMPVAR) \
+       _(1788, ZEND_SEND_VAR_EX_SPEC_VAR) \
+       _(1789, ZEND_SEND_VAR_EX_SPEC_VAR_QUICK) \
+       _(1792, ZEND_SEND_VAR_EX_SPEC_CV) \
+       _(1793, ZEND_SEND_VAR_EX_SPEC_CV_QUICK) \
+       _(1796, ZEND_SEND_REF_SPEC_VAR) \
+       _(1798, ZEND_SEND_REF_SPEC_CV) \
+       _(1799, ZEND_NEW_SPEC_CONST_UNUSED) \
+       _(1801, ZEND_NEW_SPEC_VAR_UNUSED) \
+       _(1802, ZEND_NEW_SPEC_UNUSED_UNUSED) \
+       _(1804, ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST) \
+       _(1805, ZEND_FREE_SPEC_TMPVAR) \
+       _(1806, ZEND_INIT_ARRAY_SPEC_CONST_CONST) \
+       _(1807, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \
+       _(1808, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \
+       _(1809, ZEND_INIT_ARRAY_SPEC_CONST_UNUSED) \
+       _(1810, ZEND_INIT_ARRAY_SPEC_CONST_CV) \
+       _(1811, ZEND_INIT_ARRAY_SPEC_TMP_CONST) \
+       _(1812, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \
+       _(1813, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \
+       _(1814, ZEND_INIT_ARRAY_SPEC_TMP_UNUSED) \
+       _(1815, ZEND_INIT_ARRAY_SPEC_TMP_CV) \
+       _(1816, ZEND_INIT_ARRAY_SPEC_VAR_CONST) \
+       _(1817, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \
+       _(1818, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \
+       _(1819, ZEND_INIT_ARRAY_SPEC_VAR_UNUSED) \
+       _(1820, ZEND_INIT_ARRAY_SPEC_VAR_CV) \
+       _(1826, ZEND_INIT_ARRAY_SPEC_CV_CONST) \
+       _(1827, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \
+       _(1828, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \
+       _(1829, ZEND_INIT_ARRAY_SPEC_CV_UNUSED) \
+       _(1830, ZEND_INIT_ARRAY_SPEC_CV_CV) \
+       _(1831, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST) \
+       _(1832, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \
+       _(1833, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \
+       _(1834, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED) \
+       _(1835, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV) \
+       _(1836, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST) \
+       _(1837, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \
+       _(1838, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \
+       _(1839, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED) \
+       _(1840, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV) \
+       _(1841, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST) \
+       _(1842, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \
+       _(1843, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \
+       _(1844, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED) \
+       _(1845, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV) \
+       _(1851, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST) \
+       _(1852, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \
+       _(1853, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \
+       _(1854, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED) \
+       _(1855, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV) \
+       _(1856, ZEND_INCLUDE_OR_EVAL_SPEC_CONST) \
+       _(1857, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \
+       _(1858, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \
+       _(1860, ZEND_INCLUDE_OR_EVAL_SPEC_CV) \
+       _(1861, ZEND_UNSET_VAR_SPEC_CONST_UNUSED) \
+       _(1862, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \
+       _(1863, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \
+       _(1865, ZEND_UNSET_VAR_SPEC_CV_UNUSED) \
+       _(1876, ZEND_UNSET_DIM_SPEC_VAR_CONST) \
+       _(1877, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \
+       _(1878, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \
+       _(1880, ZEND_UNSET_DIM_SPEC_VAR_CV) \
+       _(1886, ZEND_UNSET_DIM_SPEC_CV_CONST) \
+       _(1887, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \
+       _(1888, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \
+       _(1890, ZEND_UNSET_DIM_SPEC_CV_CV) \
+       _(1901, ZEND_UNSET_OBJ_SPEC_VAR_CONST) \
+       _(1902, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \
+       _(1903, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \
+       _(1905, ZEND_UNSET_OBJ_SPEC_VAR_CV) \
+       _(1906, ZEND_UNSET_OBJ_SPEC_UNUSED_CONST) \
+       _(1907, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \
+       _(1908, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \
+       _(1910, ZEND_UNSET_OBJ_SPEC_UNUSED_CV) \
+       _(1911, ZEND_UNSET_OBJ_SPEC_CV_CONST) \
+       _(1912, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \
+       _(1913, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \
+       _(1915, ZEND_UNSET_OBJ_SPEC_CV_CV) \
+       _(1916, ZEND_FE_RESET_R_SPEC_CONST) \
+       _(1917, ZEND_FE_RESET_R_SPEC_TMP) \
+       _(1918, ZEND_FE_RESET_R_SPEC_VAR) \
+       _(1920, ZEND_FE_RESET_R_SPEC_CV) \
+       _(1921, ZEND_FE_FETCH_R_SPEC_VAR) \
+       _(1922, ZEND_EXIT_SPEC_CONST) \
+       _(1923, ZEND_EXIT_SPEC_TMPVAR) \
+       _(1924, ZEND_EXIT_SPEC_TMPVAR) \
+       _(1925, ZEND_EXIT_SPEC_UNUSED) \
+       _(1926, ZEND_EXIT_SPEC_CV) \
+       _(1927, ZEND_FETCH_R_SPEC_CONST_UNUSED) \
+       _(1928, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \
+       _(1929, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \
+       _(1931, ZEND_FETCH_R_SPEC_CV_UNUSED) \
+       _(1932, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \
+       _(1933, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \
+       _(1934, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \
+       _(1936, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \
+       _(1937, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \
+       _(1938, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \
+       _(1939, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \
+       _(1941, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \
+       _(1942, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \
+       _(1943, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \
+       _(1944, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \
+       _(1946, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \
+       _(1952, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \
+       _(1953, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \
+       _(1954, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \
+       _(1956, ZEND_FETCH_DIM_R_SPEC_CV_CV) \
+       _(1957, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \
+       _(1958, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \
+       _(1959, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \
+       _(1961, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \
+       _(1962, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \
+       _(1963, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \
+       _(1964, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \
+       _(1966, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \
+       _(1967, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \
+       _(1968, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \
+       _(1969, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \
+       _(1971, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \
+       _(1972, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \
+       _(1973, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \
+       _(1974, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \
+       _(1976, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \
+       _(1977, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \
+       _(1978, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \
+       _(1979, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \
+       _(1981, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \
+       _(1982, ZEND_FETCH_W_SPEC_CONST_UNUSED) \
+       _(1983, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \
+       _(1984, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \
+       _(1986, ZEND_FETCH_W_SPEC_CV_UNUSED) \
+       _(1997, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \
+       _(1998, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \
+       _(1999, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \
+       _(2000, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED) \
+       _(2001, ZEND_FETCH_DIM_W_SPEC_VAR_CV) \
+       _(2007, ZEND_FETCH_DIM_W_SPEC_CV_CONST) \
+       _(2008, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \
+       _(2009, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \
+       _(2010, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED) \
+       _(2011, ZEND_FETCH_DIM_W_SPEC_CV_CV) \
+       _(2022, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST) \
+       _(2023, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \
+       _(2024, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \
+       _(2026, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \
+       _(2027, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \
+       _(2028, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \
+       _(2029, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \
+       _(2031, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \
+       _(2032, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \
+       _(2033, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \
+       _(2034, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \
+       _(2036, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \
+       _(2037, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \
+       _(2038, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \
+       _(2039, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \
+       _(2041, ZEND_FETCH_RW_SPEC_CV_UNUSED) \
+       _(2052, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \
+       _(2053, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \
+       _(2054, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \
+       _(2055, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED) \
+       _(2056, ZEND_FETCH_DIM_RW_SPEC_VAR_CV) \
+       _(2062, ZEND_FETCH_DIM_RW_SPEC_CV_CONST) \
+       _(2063, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \
+       _(2064, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \
+       _(2065, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED) \
+       _(2066, ZEND_FETCH_DIM_RW_SPEC_CV_CV) \
+       _(2077, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST) \
+       _(2078, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \
+       _(2079, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \
+       _(2081, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \
+       _(2082, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \
+       _(2083, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \
+       _(2084, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \
+       _(2086, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \
+       _(2087, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \
+       _(2088, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \
+       _(2089, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \
+       _(2091, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \
+       _(2092, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \
+       _(2093, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \
+       _(2094, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \
+       _(2096, ZEND_FETCH_IS_SPEC_CV_UNUSED) \
+       _(2097, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \
+       _(2098, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \
+       _(2099, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \
+       _(2101, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \
+       _(2102, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \
+       _(2103, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \
+       _(2104, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \
+       _(2106, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \
+       _(2107, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \
+       _(2108, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \
+       _(2109, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \
+       _(2111, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \
+       _(2117, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \
+       _(2118, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \
+       _(2119, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \
+       _(2121, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \
+       _(2122, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \
+       _(2123, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \
+       _(2124, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \
+       _(2126, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \
+       _(2127, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \
+       _(2128, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \
+       _(2129, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \
+       _(2131, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \
+       _(2132, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \
+       _(2133, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \
+       _(2134, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \
+       _(2136, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \
+       _(2137, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \
+       _(2138, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \
+       _(2139, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \
+       _(2141, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \
+       _(2142, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \
+       _(2143, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \
+       _(2144, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \
+       _(2146, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \
+       _(2147, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \
+       _(2148, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \
+       _(2149, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \
+       _(2151, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED) \
+       _(2152, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST) \
+       _(2153, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \
+       _(2154, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \
+       _(2155, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED) \
+       _(2156, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV) \
+       _(2157, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) \
+       _(2158, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \
+       _(2159, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \
+       _(2160, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) \
+       _(2161, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) \
+       _(2162, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST) \
+       _(2163, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \
+       _(2164, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \
+       _(2165, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED) \
+       _(2166, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV) \
+       _(2172, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST) \
+       _(2173, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \
+       _(2174, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \
+       _(2175, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED) \
+       _(2176, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV) \
+       _(2177, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST) \
+       _(2178, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \
+       _(2179, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \
+       _(2181, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV) \
+       _(2182, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) \
+       _(2183, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \
+       _(2184, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \
+       _(2186, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) \
+       _(2187, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST) \
+       _(2188, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \
+       _(2189, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \
+       _(2191, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV) \
+       _(2192, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST) \
+       _(2193, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \
+       _(2194, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \
+       _(2196, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV) \
+       _(2197, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST) \
+       _(2198, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \
+       _(2199, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \
+       _(2201, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \
+       _(2202, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \
+       _(2203, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \
+       _(2204, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \
+       _(2206, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \
+       _(2217, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \
+       _(2218, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \
+       _(2219, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \
+       _(2221, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \
+       _(2227, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \
+       _(2228, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \
+       _(2229, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \
+       _(2231, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \
+       _(2242, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \
+       _(2243, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \
+       _(2244, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \
+       _(2246, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \
+       _(2247, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \
+       _(2248, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \
+       _(2249, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \
+       _(2251, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \
+       _(2252, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \
+       _(2253, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \
+       _(2254, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \
+       _(2256, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \
+       _(2257, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \
+       _(2258, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \
+       _(2259, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \
+       _(2261, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \
+       _(2262, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \
+       _(2263, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
+       _(2264, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
+       _(2266, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \
+       _(2267, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \
+       _(2268, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
+       _(2269, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
+       _(2271, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \
+       _(2277, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \
+       _(2278, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
+       _(2279, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
+       _(2281, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \
+       _(2282, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) \
+       _(2283, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED) \
+       _(2284, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_QUICK) \
+       _(2285, ZEND_EXT_STMT_SPEC) \
+       _(2286, ZEND_EXT_FCALL_BEGIN_SPEC) \
+       _(2287, ZEND_EXT_FCALL_END_SPEC) \
+       _(2288, ZEND_EXT_NOP_SPEC) \
+       _(2289, ZEND_TICKS_SPEC) \
+       _(2290, ZEND_SEND_VAR_NO_REF_SPEC_VAR) \
+       _(2291, ZEND_CATCH_SPEC_CONST) \
+       _(2292, ZEND_THROW_SPEC_CONST) \
+       _(2293, ZEND_THROW_SPEC_TMP) \
+       _(2294, ZEND_THROW_SPEC_VAR) \
+       _(2296, ZEND_THROW_SPEC_CV) \
+       _(2297, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \
+       _(2298, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \
+       _(2299, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \
+       _(2300, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \
+       _(2301, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \
+       _(2302, ZEND_CLONE_SPEC_CONST) \
+       _(2303, ZEND_CLONE_SPEC_TMPVAR) \
+       _(2304, ZEND_CLONE_SPEC_TMPVAR) \
+       _(2305, ZEND_CLONE_SPEC_UNUSED) \
+       _(2306, ZEND_CLONE_SPEC_CV) \
+       _(2307, ZEND_RETURN_BY_REF_SPEC_CONST) \
+       _(2308, ZEND_RETURN_BY_REF_SPEC_TMP) \
+       _(2309, ZEND_RETURN_BY_REF_SPEC_VAR) \
+       _(2311, ZEND_RETURN_BY_REF_SPEC_CV) \
+       _(2312, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) \
+       _(2313, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \
+       _(2314, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \
+       _(2316, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \
+       _(2317, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \
+       _(2318, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \
+       _(2319, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \
+       _(2321, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \
+       _(2322, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \
+       _(2323, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \
+       _(2324, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \
+       _(2326, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \
+       _(2327, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \
+       _(2328, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \
+       _(2329, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \
+       _(2331, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \
+       _(2332, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \
+       _(2333, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \
+       _(2334, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \
+       _(2336, ZEND_INIT_METHOD_CALL_SPEC_CV_CV) \
+       _(2337, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) \
+       _(2338, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \
+       _(2339, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \
+       _(2340, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) \
+       _(2341, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) \
+       _(2347, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) \
+       _(2348, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \
+       _(2349, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \
+       _(2350, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) \
+       _(2351, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) \
+       _(2352, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) \
+       _(2353, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \
+       _(2354, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \
+       _(2355, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) \
+       _(2356, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) \
+       _(2362, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) \
+       _(2363, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \
+       _(2364, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \
+       _(2366, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED) \
+       _(2367, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST) \
+       _(2368, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \
+       _(2369, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \
+       _(2371, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \
+       _(2372, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \
+       _(2373, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \
+       _(2374, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \
+       _(2376, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \
+       _(2377, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \
+       _(2378, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \
+       _(2379, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \
+       _(2381, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \
+       _(2387, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \
+       _(2388, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \
+       _(2389, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \
+       _(2391, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV) \
+       _(2392, ZEND_SEND_VAL_EX_SPEC_CONST) \
+       _(2393, ZEND_SEND_VAL_EX_SPEC_CONST_QUICK) \
+       _(2394, ZEND_SEND_VAL_EX_SPEC_TMP) \
+       _(2395, ZEND_SEND_VAL_EX_SPEC_TMP_QUICK) \
+       _(2404, ZEND_SEND_VAR_SPEC_VAR) \
+       _(2406, ZEND_SEND_VAR_SPEC_CV) \
+       _(2407, ZEND_INIT_USER_CALL_SPEC_CONST_CONST) \
+       _(2408, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \
+       _(2409, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \
+       _(2411, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \
+       _(2412, ZEND_SEND_ARRAY_SPEC) \
+       _(2413, ZEND_SEND_USER_SPEC_CONST) \
+       _(2414, ZEND_SEND_USER_SPEC_TMP) \
+       _(2415, ZEND_SEND_USER_SPEC_VAR) \
+       _(2417, ZEND_SEND_USER_SPEC_CV) \
+       _(2418, ZEND_STRLEN_SPEC_CONST) \
+       _(2419, ZEND_STRLEN_SPEC_TMPVAR) \
+       _(2420, ZEND_STRLEN_SPEC_TMPVAR) \
+       _(2422, ZEND_STRLEN_SPEC_CV) \
+       _(2423, ZEND_DEFINED_SPEC_CONST) \
+       _(2424, ZEND_TYPE_CHECK_SPEC_CONST) \
+       _(2425, ZEND_TYPE_CHECK_SPEC_TMPVAR) \
+       _(2426, ZEND_TYPE_CHECK_SPEC_TMPVAR) \
+       _(2428, ZEND_TYPE_CHECK_SPEC_CV) \
+       _(2429, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \
+       _(2430, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \
+       _(2431, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \
+       _(2432, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \
+       _(2433, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \
+       _(2434, ZEND_FE_RESET_RW_SPEC_CONST) \
+       _(2435, ZEND_FE_RESET_RW_SPEC_TMP) \
+       _(2436, ZEND_FE_RESET_RW_SPEC_VAR) \
+       _(2438, ZEND_FE_RESET_RW_SPEC_CV) \
+       _(2439, ZEND_FE_FETCH_RW_SPEC_VAR) \
+       _(2440, ZEND_FE_FREE_SPEC_TMPVAR) \
+       _(2441, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \
+       _(2442, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \
+       _(2443, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \
+       _(2445, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \
+       _(2446, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \
+       _(2447, ZEND_DO_ICALL_SPEC_RETVAL_USED) \
+       _(2448, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \
+       _(2449, ZEND_DO_UCALL_SPEC_RETVAL_USED) \
+       _(2450, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \
+       _(2451, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \
+       _(2462, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \
+       _(2463, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \
+       _(2464, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \
+       _(2466, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \
+       _(2467, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \
+       _(2468, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \
+       _(2469, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \
+       _(2471, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \
+       _(2472, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \
+       _(2473, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \
+       _(2474, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \
+       _(2476, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \
+       _(2487, ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST) \
+       _(2488, ZEND_PRE_DEC_OBJ_SPEC_VAR_TMPVAR) \
+       _(2489, ZEND_PRE_DEC_OBJ_SPEC_VAR_TMPVAR) \
+       _(2491, ZEND_PRE_DEC_OBJ_SPEC_VAR_CV) \
+       _(2492, ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST) \
+       _(2493, ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMPVAR) \
+       _(2494, ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMPVAR) \
+       _(2496, ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV) \
+       _(2497, ZEND_PRE_DEC_OBJ_SPEC_CV_CONST) \
+       _(2498, ZEND_PRE_DEC_OBJ_SPEC_CV_TMPVAR) \
+       _(2499, ZEND_PRE_DEC_OBJ_SPEC_CV_TMPVAR) \
+       _(2501, ZEND_PRE_DEC_OBJ_SPEC_CV_CV) \
+       _(2512, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \
+       _(2513, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \
+       _(2514, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \
+       _(2516, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \
+       _(2517, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \
+       _(2518, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \
+       _(2519, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \
+       _(2521, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \
+       _(2522, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \
+       _(2523, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \
+       _(2524, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \
+       _(2526, ZEND_POST_INC_OBJ_SPEC_CV_CV) \
+       _(2537, ZEND_POST_DEC_OBJ_SPEC_VAR_CONST) \
+       _(2538, ZEND_POST_DEC_OBJ_SPEC_VAR_TMPVAR) \
+       _(2539, ZEND_POST_DEC_OBJ_SPEC_VAR_TMPVAR) \
+       _(2541, ZEND_POST_DEC_OBJ_SPEC_VAR_CV) \
+       _(2542, ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST) \
+       _(2543, ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMPVAR) \
+       _(2544, ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMPVAR) \
+       _(2546, ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV) \
+       _(2547, ZEND_POST_DEC_OBJ_SPEC_CV_CONST) \
+       _(2548, ZEND_POST_DEC_OBJ_SPEC_CV_TMPVAR) \
+       _(2549, ZEND_POST_DEC_OBJ_SPEC_CV_TMPVAR) \
+       _(2551, ZEND_POST_DEC_OBJ_SPEC_CV_CV) \
+       _(2602, ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST) \
+       _(2603, ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP) \
+       _(2604, ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR) \
+       _(2606, ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV) \
+       _(2607, ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST) \
+       _(2608, ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP) \
+       _(2609, ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR) \
+       _(2611, ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV) \
+       _(2612, ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST) \
+       _(2613, ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP) \
+       _(2614, ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR) \
+       _(2616, ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV) \
+       _(2622, ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST) \
+       _(2623, ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP) \
+       _(2624, ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR) \
+       _(2626, ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV) \
+       _(2627, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST) \
+       _(2628, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP) \
+       _(2629, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR) \
+       _(2631, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV) \
+       _(2632, ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST) \
+       _(2633, ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP) \
+       _(2634, ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) \
+       _(2636, ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV) \
+       _(2637, ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST) \
+       _(2638, ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP) \
+       _(2639, ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) \
+       _(2641, ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV) \
+       _(2647, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST) \
+       _(2648, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP) \
+       _(2649, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR) \
+       _(2651, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV) \
+       _(2652, ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST) \
+       _(2653, ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP) \
+       _(2654, ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR) \
+       _(2656, ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV) \
+       _(2657, ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST) \
+       _(2658, ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP) \
+       _(2659, ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR) \
+       _(2661, ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV) \
+       _(2662, ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST) \
+       _(2663, ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP) \
+       _(2664, ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR) \
+       _(2666, ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV) \
+       _(2672, ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST) \
+       _(2673, ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP) \
+       _(2674, ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR) \
+       _(2676, ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV) \
+       _(2683, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \
+       _(2685, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \
+       _(2686, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \
+       _(2688, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \
+       _(2690, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \
+       _(2691, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \
+       _(2698, ZEND_INSTANCEOF_SPEC_CV_CONST) \
+       _(2700, ZEND_INSTANCEOF_SPEC_CV_VAR) \
+       _(2701, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \
+       _(2703, ZEND_DECLARE_CLASS_SPEC_CONST) \
+       _(2704, ZEND_DECLARE_INHERITED_CLASS_SPEC_CONST_CONST) \
+       _(2705, ZEND_DECLARE_FUNCTION_SPEC) \
+       _(2706, ZEND_YIELD_FROM_SPEC_CONST) \
+       _(2707, ZEND_YIELD_FROM_SPEC_TMP) \
+       _(2708, ZEND_YIELD_FROM_SPEC_VAR) \
+       _(2710, ZEND_YIELD_FROM_SPEC_CV) \
+       _(2711, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \
+       _(2712, ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_CONST_CONST) \
+       _(2763, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST) \
+       _(2764, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP) \
+       _(2765, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR) \
+       _(2767, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV) \
+       _(2768, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST) \
+       _(2769, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP) \
+       _(2770, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR) \
+       _(2772, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV) \
+       _(2773, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST) \
+       _(2774, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP) \
+       _(2775, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR) \
+       _(2777, ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV) \
+       _(2778, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST) \
+       _(2779, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP) \
+       _(2780, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR) \
+       _(2782, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV) \
+       _(2783, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST) \
+       _(2784, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP) \
+       _(2785, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR) \
+       _(2787, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV) \
+       _(2813, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST) \
+       _(2814, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP) \
+       _(2815, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR) \
+       _(2817, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV) \
+       _(2818, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST) \
+       _(2819, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP) \
+       _(2820, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR) \
+       _(2822, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV) \
+       _(2823, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST) \
+       _(2824, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP) \
+       _(2825, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR) \
+       _(2827, ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV) \
+       _(2828, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST) \
+       _(2829, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP) \
+       _(2830, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR) \
+       _(2832, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV) \
+       _(2833, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST) \
+       _(2834, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP) \
+       _(2835, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR) \
+       _(2837, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV) \
+       _(2838, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \
+       _(2839, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \
+       _(2840, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \
+       _(2842, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \
+       _(2843, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \
+       _(2844, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
+       _(2845, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
+       _(2847, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \
+       _(2848, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \
+       _(2849, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
+       _(2850, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
+       _(2852, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \
+       _(2853, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \
+       _(2854, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \
+       _(2855, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \
+       _(2857, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \
+       _(2858, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \
+       _(2859, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \
+       _(2860, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \
+       _(2862, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \
+       _(2863, ZEND_HANDLE_EXCEPTION_SPEC) \
+       _(2864, ZEND_USER_OPCODE_SPEC) \
+       _(2865, ZEND_ASSERT_CHECK_SPEC) \
+       _(2866, ZEND_JMP_SET_SPEC_CONST) \
+       _(2867, ZEND_JMP_SET_SPEC_TMP) \
+       _(2868, ZEND_JMP_SET_SPEC_VAR) \
+       _(2870, ZEND_JMP_SET_SPEC_CV) \
+       _(2871, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) \
+       _(2872, ZEND_SEPARATE_SPEC_VAR_UNUSED) \
+       _(2873, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \
+       _(2874, ZEND_CALL_TRAMPOLINE_SPEC) \
+       _(2875, ZEND_DISCARD_EXCEPTION_SPEC) \
+       _(2876, ZEND_YIELD_SPEC_CONST_CONST) \
+       _(2877, ZEND_YIELD_SPEC_CONST_TMP) \
+       _(2878, ZEND_YIELD_SPEC_CONST_VAR) \
+       _(2879, ZEND_YIELD_SPEC_CONST_UNUSED) \
+       _(2880, ZEND_YIELD_SPEC_CONST_CV) \
+       _(2881, ZEND_YIELD_SPEC_TMP_CONST) \
+       _(2882, ZEND_YIELD_SPEC_TMP_TMP) \
+       _(2883, ZEND_YIELD_SPEC_TMP_VAR) \
+       _(2884, ZEND_YIELD_SPEC_TMP_UNUSED) \
+       _(2885, ZEND_YIELD_SPEC_TMP_CV) \
+       _(2886, ZEND_YIELD_SPEC_VAR_CONST) \
+       _(2887, ZEND_YIELD_SPEC_VAR_TMP) \
+       _(2888, ZEND_YIELD_SPEC_VAR_VAR) \
+       _(2889, ZEND_YIELD_SPEC_VAR_UNUSED) \
+       _(2890, ZEND_YIELD_SPEC_VAR_CV) \
+       _(2891, ZEND_YIELD_SPEC_UNUSED_CONST) \
+       _(2892, ZEND_YIELD_SPEC_UNUSED_TMP) \
+       _(2893, ZEND_YIELD_SPEC_UNUSED_VAR) \
+       _(2894, ZEND_YIELD_SPEC_UNUSED_UNUSED) \
+       _(2895, ZEND_YIELD_SPEC_UNUSED_CV) \
+       _(2896, ZEND_YIELD_SPEC_CV_CONST) \
+       _(2897, ZEND_YIELD_SPEC_CV_TMP) \
+       _(2898, ZEND_YIELD_SPEC_CV_VAR) \
+       _(2899, ZEND_YIELD_SPEC_CV_UNUSED) \
+       _(2900, ZEND_YIELD_SPEC_CV_CV) \
+       _(2901, ZEND_GENERATOR_RETURN_SPEC_CONST) \
+       _(2902, ZEND_GENERATOR_RETURN_SPEC_TMP) \
+       _(2903, ZEND_GENERATOR_RETURN_SPEC_VAR) \
+       _(2905, ZEND_GENERATOR_RETURN_SPEC_CV) \
+       _(2906, ZEND_FAST_CALL_SPEC) \
+       _(2907, ZEND_FAST_RET_SPEC) \
+       _(2908, ZEND_RECV_VARIADIC_SPEC_UNUSED) \
+       _(2909, ZEND_SEND_UNPACK_SPEC) \
+       _(2910, ZEND_POW_SPEC_CONST_CONST) \
+       _(2911, ZEND_POW_SPEC_CONST_TMPVAR) \
+       _(2912, ZEND_POW_SPEC_CONST_TMPVAR) \
+       _(2914, ZEND_POW_SPEC_CONST_CV) \
+       _(2915, ZEND_POW_SPEC_TMPVAR_CONST) \
+       _(2916, ZEND_POW_SPEC_TMPVAR_TMPVAR) \
+       _(2917, ZEND_POW_SPEC_TMPVAR_TMPVAR) \
+       _(2919, ZEND_POW_SPEC_TMPVAR_CV) \
+       _(2920, ZEND_POW_SPEC_TMPVAR_CONST) \
+       _(2921, ZEND_POW_SPEC_TMPVAR_TMPVAR) \
+       _(2922, ZEND_POW_SPEC_TMPVAR_TMPVAR) \
+       _(2924, ZEND_POW_SPEC_TMPVAR_CV) \
+       _(2930, ZEND_POW_SPEC_CV_CONST) \
+       _(2931, ZEND_POW_SPEC_CV_TMPVAR) \
+       _(2932, ZEND_POW_SPEC_CV_TMPVAR) \
+       _(2934, ZEND_POW_SPEC_CV_CV) \
+       _(2938, ZEND_ASSIGN_POW_SPEC_CONST_CONST_STATIC_PROP) \
+       _(2942, ZEND_ASSIGN_POW_SPEC_CONST_TMPVAR_STATIC_PROP) \
+       _(2946, ZEND_ASSIGN_POW_SPEC_CONST_TMPVAR_STATIC_PROP) \
+       _(2950, ZEND_ASSIGN_POW_SPEC_CONST_UNUSED_STATIC_PROP) \
+       _(2958, ZEND_ASSIGN_POW_SPEC_TMP_CONST_STATIC_PROP) \
+       _(2962, ZEND_ASSIGN_POW_SPEC_TMP_TMPVAR_STATIC_PROP) \
+       _(2966, ZEND_ASSIGN_POW_SPEC_TMP_TMPVAR_STATIC_PROP) \
+       _(2970, ZEND_ASSIGN_POW_SPEC_TMP_UNUSED_STATIC_PROP) \
+       _(2975, ZEND_ASSIGN_POW_SPEC_VAR_CONST) \
+       _(2976, ZEND_ASSIGN_POW_SPEC_VAR_CONST_DIM) \
+       _(2977, ZEND_ASSIGN_POW_SPEC_VAR_CONST_OBJ) \
+       _(2978, ZEND_ASSIGN_POW_SPEC_VAR_CONST_STATIC_PROP) \
+       _(2979, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR) \
+       _(2980, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM) \
+       _(2981, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ) \
+       _(2982, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_STATIC_PROP) \
+       _(2983, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR) \
+       _(2984, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_DIM) \
+       _(2985, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_OBJ) \
+       _(2986, ZEND_ASSIGN_POW_SPEC_VAR_TMPVAR_STATIC_PROP) \
+       _(2988, ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_DIM) \
+       _(2990, ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_STATIC_PROP) \
+       _(2991, ZEND_ASSIGN_POW_SPEC_VAR_CV) \
+       _(2992, ZEND_ASSIGN_POW_SPEC_VAR_CV_DIM) \
+       _(2993, ZEND_ASSIGN_POW_SPEC_VAR_CV_OBJ) \
+       _(2997, ZEND_ASSIGN_POW_SPEC_UNUSED_CONST_OBJ) \
+       _(3001, ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(3005, ZEND_ASSIGN_POW_SPEC_UNUSED_TMPVAR_OBJ) \
+       _(3013, ZEND_ASSIGN_POW_SPEC_UNUSED_CV_OBJ) \
+       _(3015, ZEND_ASSIGN_POW_SPEC_CV_CONST) \
+       _(3016, ZEND_ASSIGN_POW_SPEC_CV_CONST_DIM) \
+       _(3017, ZEND_ASSIGN_POW_SPEC_CV_CONST_OBJ) \
+       _(3018, ZEND_ASSIGN_POW_SPEC_CV_CONST_STATIC_PROP) \
+       _(3019, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR) \
+       _(3020, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM) \
+       _(3021, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ) \
+       _(3022, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_STATIC_PROP) \
+       _(3023, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR) \
+       _(3024, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_DIM) \
+       _(3025, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_OBJ) \
+       _(3026, ZEND_ASSIGN_POW_SPEC_CV_TMPVAR_STATIC_PROP) \
+       _(3028, ZEND_ASSIGN_POW_SPEC_CV_UNUSED_DIM) \
+       _(3030, ZEND_ASSIGN_POW_SPEC_CV_UNUSED_STATIC_PROP) \
+       _(3031, ZEND_ASSIGN_POW_SPEC_CV_CV) \
+       _(3032, ZEND_ASSIGN_POW_SPEC_CV_CV_DIM) \
+       _(3033, ZEND_ASSIGN_POW_SPEC_CV_CV_OBJ) \
+       _(3035, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \
+       _(3036, ZEND_COALESCE_SPEC_CONST) \
+       _(3037, ZEND_COALESCE_SPEC_TMPVAR) \
+       _(3038, ZEND_COALESCE_SPEC_TMPVAR) \
+       _(3040, ZEND_COALESCE_SPEC_CV) \
+       _(3041, ZEND_SPACESHIP_SPEC_CONST_CONST) \
+       _(3042, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \
+       _(3043, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \
+       _(3045, ZEND_SPACESHIP_SPEC_CONST_CV) \
+       _(3046, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \
+       _(3047, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
+       _(3048, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
+       _(3050, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \
+       _(3051, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \
+       _(3052, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
+       _(3053, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
+       _(3055, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \
+       _(3061, ZEND_SPACESHIP_SPEC_CV_CONST) \
+       _(3062, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \
+       _(3063, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \
+       _(3065, ZEND_SPACESHIP_SPEC_CV_CV) \
+       _(3066, ZEND_DECLARE_ANON_CLASS_SPEC) \
+       _(3067, ZEND_DECLARE_ANON_INHERITED_CLASS_SPEC_CONST_CONST) \
+       _(3068, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_CONST) \
+       _(3070, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_VAR) \
+       _(3071, ZEND_FETCH_STATIC_PROP_R_SPEC_CONST_UNUSED) \
+       _(3073, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST) \
+       _(3075, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR) \
+       _(3076, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_UNUSED) \
+       _(3078, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_CONST) \
+       _(3080, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR) \
+       _(3081, ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_UNUSED) \
+       _(3088, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_CONST) \
+       _(3090, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_VAR) \
+       _(3091, ZEND_FETCH_STATIC_PROP_R_SPEC_CV_UNUSED) \
+       _(3093, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_CONST) \
+       _(3095, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_VAR) \
+       _(3096, ZEND_FETCH_STATIC_PROP_W_SPEC_CONST_UNUSED) \
+       _(3098, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_CONST) \
+       _(3100, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_VAR) \
+       _(3101, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_UNUSED) \
+       _(3103, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_CONST) \
+       _(3105, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_VAR) \
+       _(3106, ZEND_FETCH_STATIC_PROP_W_SPEC_TMPVAR_UNUSED) \
+       _(3113, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_CONST) \
+       _(3115, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_VAR) \
+       _(3116, ZEND_FETCH_STATIC_PROP_W_SPEC_CV_UNUSED) \
+       _(3118, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_CONST) \
+       _(3120, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_VAR) \
+       _(3121, ZEND_FETCH_STATIC_PROP_RW_SPEC_CONST_UNUSED) \
+       _(3123, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_CONST) \
+       _(3125, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_VAR) \
+       _(3126, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_UNUSED) \
+       _(3128, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_CONST) \
+       _(3130, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_VAR) \
+       _(3131, ZEND_FETCH_STATIC_PROP_RW_SPEC_TMPVAR_UNUSED) \
+       _(3138, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_CONST) \
+       _(3140, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_VAR) \
+       _(3141, ZEND_FETCH_STATIC_PROP_RW_SPEC_CV_UNUSED) \
+       _(3143, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_CONST) \
+       _(3145, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_VAR) \
+       _(3146, ZEND_FETCH_STATIC_PROP_IS_SPEC_CONST_UNUSED) \
+       _(3148, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_CONST) \
+       _(3150, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_VAR) \
+       _(3151, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_UNUSED) \
+       _(3153, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_CONST) \
+       _(3155, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_VAR) \
+       _(3156, ZEND_FETCH_STATIC_PROP_IS_SPEC_TMPVAR_UNUSED) \
+       _(3163, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_CONST) \
+       _(3165, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_VAR) \
+       _(3166, ZEND_FETCH_STATIC_PROP_IS_SPEC_CV_UNUSED) \
+       _(3168, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_CONST) \
+       _(3170, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_VAR) \
+       _(3171, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CONST_UNUSED) \
+       _(3173, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_CONST) \
+       _(3175, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_VAR) \
+       _(3176, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_UNUSED) \
+       _(3178, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_CONST) \
+       _(3180, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_VAR) \
+       _(3181, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TMPVAR_UNUSED) \
+       _(3188, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_CONST) \
+       _(3190, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_VAR) \
+       _(3191, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_CV_UNUSED) \
+       _(3193, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_CONST) \
+       _(3195, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_VAR) \
+       _(3196, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CONST_UNUSED) \
+       _(3198, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_CONST) \
+       _(3200, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_VAR) \
+       _(3201, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_UNUSED) \
+       _(3203, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_CONST) \
+       _(3205, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_VAR) \
+       _(3206, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TMPVAR_UNUSED) \
+       _(3213, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_CONST) \
+       _(3215, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_VAR) \
+       _(3216, ZEND_FETCH_STATIC_PROP_UNSET_SPEC_CV_UNUSED) \
+       _(3218, ZEND_UNSET_STATIC_PROP_SPEC_CONST_CONST) \
+       _(3220, ZEND_UNSET_STATIC_PROP_SPEC_CONST_VAR) \
+       _(3221, ZEND_UNSET_STATIC_PROP_SPEC_CONST_UNUSED) \
+       _(3223, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_CONST) \
+       _(3225, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR) \
+       _(3226, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
+       _(3228, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_CONST) \
+       _(3230, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_VAR) \
+       _(3231, ZEND_UNSET_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
+       _(3238, ZEND_UNSET_STATIC_PROP_SPEC_CV_CONST) \
+       _(3240, ZEND_UNSET_STATIC_PROP_SPEC_CV_VAR) \
+       _(3241, ZEND_UNSET_STATIC_PROP_SPEC_CV_UNUSED) \
+       _(3243, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_CONST) \
+       _(3245, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_VAR) \
+       _(3246, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CONST_UNUSED) \
+       _(3248, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_CONST) \
+       _(3250, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_VAR) \
+       _(3251, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
+       _(3253, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_CONST) \
+       _(3255, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_VAR) \
+       _(3256, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
+       _(3263, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_CONST) \
+       _(3265, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_VAR) \
+       _(3266, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC_CV_UNUSED) \
+       _(3268, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \
+       _(3270, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \
+       _(3271, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \
+       _(3273, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \
+       _(3274, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \
+       _(3275, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \
+       _(3276, ZEND_SEND_FUNC_ARG_SPEC_VAR) \
+       _(3277, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \
+       _(3278, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \
+       _(3279, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
+       _(3280, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
+       _(3282, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
+       _(3283, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \
+       _(3284, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
+       _(3285, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
+       _(3287, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
+       _(3288, ZEND_IN_ARRAY_SPEC_CONST_CONST) \
+       _(3289, ZEND_IN_ARRAY_SPEC_TMP_CONST) \
+       _(3290, ZEND_IN_ARRAY_SPEC_VAR_CONST) \
+       _(3292, ZEND_IN_ARRAY_SPEC_CV_CONST) \
+       _(3293, ZEND_COUNT_SPEC_CONST_UNUSED) \
+       _(3294, ZEND_COUNT_SPEC_TMP_UNUSED) \
+       _(3295, ZEND_COUNT_SPEC_VAR_UNUSED) \
+       _(3297, ZEND_COUNT_SPEC_CV_UNUSED) \
+       _(3298, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \
+       _(3299, ZEND_GET_CLASS_SPEC_TMP_UNUSED) \
+       _(3300, ZEND_GET_CLASS_SPEC_VAR_UNUSED) \
+       _(3301, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \
+       _(3302, ZEND_GET_CLASS_SPEC_CV_UNUSED) \
+       _(3303, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \
+       _(3304, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \
+       _(3305, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \
+       _(3306, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \
+       _(3308, ZEND_GET_TYPE_SPEC_CV_UNUSED) \
+       _(3309, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \
+       _(3310, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \
+       _(3313, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \
+       _(3315, ZEND_UNSET_CV_SPEC_CV_UNUSED) \
+       _(3316, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \
+       _(3317, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \
+       _(3318, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \
+       _(3319, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \
+       _(3320, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \
+       _(3322, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \
+       _(3323, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \
+       _(3324, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \
+       _(3325, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \
+       _(3327, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \
+       _(3328, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \
+       _(3329, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
+       _(3330, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
+       _(3332, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \
+       _(3333, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \
+       _(3334, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
+       _(3335, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
+       _(3337, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \
+       _(3343, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \
+       _(3344, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \
+       _(3345, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \
+       _(3347, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \
+       _(3400, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_VAR) \
+       _(3402, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV) \
+       _(3405, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR) \
+       _(3407, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV) \
+       _(3410, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR) \
+       _(3412, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV) \
+       _(3420, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_VAR) \
+       _(3422, ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV) \
+       _(3425, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR) \
+       _(3427, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV) \
+       _(3430, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) \
+       _(3432, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV) \
+       _(3435, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) \
+       _(3437, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV) \
+       _(3445, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR) \
+       _(3447, ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV) \
+       _(3450, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_VAR) \
+       _(3452, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV) \
+       _(3455, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR) \
+       _(3457, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV) \
+       _(3460, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR) \
+       _(3462, ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV) \
+       _(3470, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_VAR) \
+       _(3472, ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV) \
+       _(3473, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_CONST) \
+       _(3474, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_TMP) \
+       _(3475, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_VAR) \
+       _(3477, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_CONST_OP_DATA_CV) \
+       _(3483, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_CONST) \
+       _(3484, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_TMP) \
+       _(3485, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_VAR) \
+       _(3487, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_VAR_OP_DATA_CV) \
+       _(3488, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_CONST) \
+       _(3489, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_TMP) \
+       _(3490, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_VAR) \
+       _(3492, ZEND_ASSIGN_STATIC_PROP_SPEC_CONST_UNUSED_OP_DATA_CV) \
+       _(3498, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CONST) \
+       _(3499, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_TMP) \
+       _(3500, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_VAR) \
+       _(3502, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CV) \
+       _(3508, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CONST) \
+       _(3509, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_TMP) \
+       _(3510, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_VAR) \
+       _(3512, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CV) \
+       _(3513, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CONST) \
+       _(3514, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_TMP) \
+       _(3515, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_VAR) \
+       _(3517, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CV) \
+       _(3523, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CONST) \
+       _(3524, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_TMP) \
+       _(3525, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_VAR) \
+       _(3527, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_CONST_OP_DATA_CV) \
+       _(3533, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CONST) \
+       _(3534, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_TMP) \
+       _(3535, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_VAR) \
+       _(3537, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_VAR_OP_DATA_CV) \
+       _(3538, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CONST) \
+       _(3539, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_TMP) \
+       _(3540, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_VAR) \
+       _(3542, ZEND_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_OP_DATA_CV) \
+       _(3573, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_CONST) \
+       _(3574, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_TMP) \
+       _(3575, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_VAR) \
+       _(3577, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_CONST_OP_DATA_CV) \
+       _(3583, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_CONST) \
+       _(3584, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_TMP) \
+       _(3585, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_VAR) \
+       _(3587, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_VAR_OP_DATA_CV) \
+       _(3588, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_CONST) \
+       _(3589, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_TMP) \
+       _(3590, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_VAR) \
+       _(3592, ZEND_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_OP_DATA_CV) \
+       _(3598, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_CONST) \
+       _(3600, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_VAR) \
+       _(3601, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CONST_UNUSED) \
+       _(3603, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_CONST) \
+       _(3605, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_VAR) \
+       _(3606, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_UNUSED) \
+       _(3608, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_CONST) \
+       _(3610, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_VAR) \
+       _(3611, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_TMPVAR_UNUSED) \
+       _(3618, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_CONST) \
+       _(3620, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_VAR) \
+       _(3621, ZEND_ASSIGN_STATIC_PROP_REF_SPEC_CV_UNUSED) \
+       _(3623, ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_CONST) \
+       _(3625, ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_VAR) \
+       _(3626, ZEND_PRE_INC_STATIC_PROP_SPEC_CONST_UNUSED) \
+       _(3628, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_CONST) \
+       _(3630, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_VAR) \
+       _(3631, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
+       _(3633, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_CONST) \
+       _(3635, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_VAR) \
+       _(3636, ZEND_PRE_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
+       _(3643, ZEND_PRE_INC_STATIC_PROP_SPEC_CV_CONST) \
+       _(3645, ZEND_PRE_INC_STATIC_PROP_SPEC_CV_VAR) \
+       _(3646, ZEND_PRE_INC_STATIC_PROP_SPEC_CV_UNUSED) \
+       _(3648, ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_CONST) \
+       _(3650, ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_VAR) \
+       _(3651, ZEND_PRE_DEC_STATIC_PROP_SPEC_CONST_UNUSED) \
+       _(3653, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_CONST) \
+       _(3655, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_VAR) \
+       _(3656, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
+       _(3658, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_CONST) \
+       _(3660, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_VAR) \
+       _(3661, ZEND_PRE_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
+       _(3668, ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_CONST) \
+       _(3670, ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_VAR) \
+       _(3671, ZEND_PRE_DEC_STATIC_PROP_SPEC_CV_UNUSED) \
+       _(3673, ZEND_POST_INC_STATIC_PROP_SPEC_CONST_CONST) \
+       _(3675, ZEND_POST_INC_STATIC_PROP_SPEC_CONST_VAR) \
+       _(3676, ZEND_POST_INC_STATIC_PROP_SPEC_CONST_UNUSED) \
+       _(3678, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_CONST) \
+       _(3680, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_VAR) \
+       _(3681, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
+       _(3683, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_CONST) \
+       _(3685, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_VAR) \
+       _(3686, ZEND_POST_INC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
+       _(3693, ZEND_POST_INC_STATIC_PROP_SPEC_CV_CONST) \
+       _(3695, ZEND_POST_INC_STATIC_PROP_SPEC_CV_VAR) \
+       _(3696, ZEND_POST_INC_STATIC_PROP_SPEC_CV_UNUSED) \
+       _(3698, ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_CONST) \
+       _(3700, ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_VAR) \
+       _(3701, ZEND_POST_DEC_STATIC_PROP_SPEC_CONST_UNUSED) \
+       _(3703, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_CONST) \
+       _(3705, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_VAR) \
+       _(3706, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
+       _(3708, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_CONST) \
+       _(3710, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_VAR) \
+       _(3711, ZEND_POST_DEC_STATIC_PROP_SPEC_TMPVAR_UNUSED) \
+       _(3718, ZEND_POST_DEC_STATIC_PROP_SPEC_CV_CONST) \
+       _(3720, ZEND_POST_DEC_STATIC_PROP_SPEC_CV_VAR) \
+       _(3721, ZEND_POST_DEC_STATIC_PROP_SPEC_CV_UNUSED) \
+       _(3723, ZEND_JMP_FORWARD_SPEC) \
+       _(3729, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+       _(3730, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3731, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3733, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3734, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+       _(3735, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3736, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3738, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3744, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+       _(3745, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3746, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3748, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3754, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
+       _(3755, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3756, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3758, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3759, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
+       _(3760, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3761, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3763, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3769, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
+       _(3770, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3771, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3773, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3779, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3780, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3781, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3783, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3784, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3785, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3786, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3788, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3794, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3795, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3796, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3798, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3800, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+       _(3801, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+       _(3803, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+       _(3804, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+       _(3805, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3806, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3808, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3809, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+       _(3810, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3811, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3813, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3819, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+       _(3820, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3821, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3823, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3825, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+       _(3826, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+       _(3828, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+       _(3829, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
+       _(3830, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3831, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3833, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3834, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
+       _(3835, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3836, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3838, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3844, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
+       _(3845, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3846, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3848, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3850, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3851, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3853, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3854, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3855, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3856, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3858, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3859, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3860, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3861, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3863, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3869, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3870, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3871, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3873, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3879, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+       _(3880, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3881, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3883, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3884, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+       _(3885, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3886, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3888, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3894, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+       _(3895, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3896, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3898, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3904, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3905, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3906, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3908, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3909, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3910, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3911, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3913, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3919, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3920, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3921, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3923, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3929, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3930, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3931, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3933, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3934, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3935, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3936, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3938, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3944, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3945, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3946, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3948, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3964, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3965, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3966, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3967, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3968, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3969, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3970, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3971, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3972, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3976, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3977, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3978, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3979, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3980, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3981, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3982, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3983, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3984, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3985, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3986, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3987, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3991, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3992, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3993, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4009, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(4010, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4011, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4012, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4013, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4014, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4015, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4016, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4017, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4021, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4022, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4023, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4039, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4040, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4041, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4042, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4043, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4044, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4045, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4046, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4047, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4051, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4052, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4053, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4054, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4055, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4056, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4057, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4058, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4059, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4060, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4061, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4062, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4066, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4067, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4068, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4084, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4085, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4086, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4087, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4088, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4089, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4090, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4091, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4092, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4096, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4097, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4098, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4114, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(4115, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4116, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4117, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4118, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4119, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4120, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4121, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4122, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4126, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4127, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4128, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4129, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(4130, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4131, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4132, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4133, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4134, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4135, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4136, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4137, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4141, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4142, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4143, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4159, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(4160, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4161, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4162, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4163, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4164, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4165, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4166, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4167, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4171, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4172, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4173, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4189, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4190, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4191, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4192, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4193, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4194, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4195, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4196, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4197, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4201, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4202, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4203, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4204, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4205, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4206, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4207, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4208, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4209, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4210, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4211, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4212, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4216, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4217, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4218, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4234, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4235, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4236, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4237, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4238, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4239, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4240, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4241, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4242, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4246, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4247, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4248, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4252, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+       _(4253, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4254, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4255, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+       _(4256, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4257, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4261, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+       _(4262, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4263, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4264, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+       _(4265, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4266, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4267, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4268, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4269, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4270, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4271, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4272, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4276, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4277, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4278, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4279, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+       _(4280, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4281, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4282, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4283, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4284, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4285, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4286, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4287, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4291, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4292, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4293, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4309, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+       _(4310, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4311, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4312, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4313, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4314, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4315, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4316, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4317, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4321, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4322, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4323, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4327, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(4328, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4329, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4330, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(4331, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4332, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4336, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(4337, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4338, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4339, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4340, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4341, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4342, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4343, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4344, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4345, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4346, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4347, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4351, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4352, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4353, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4354, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4355, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4356, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4357, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4358, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4359, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4360, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4361, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4362, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4366, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4367, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4368, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4384, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4385, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4386, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4387, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4388, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4389, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4390, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4391, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4392, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4396, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4397, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4398, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4402, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+       _(4403, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4404, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4405, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+       _(4406, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4407, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4411, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+       _(4412, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4413, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4414, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(4415, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4416, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4417, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4418, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4419, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4420, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4421, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4422, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4426, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4427, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4428, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4429, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(4430, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4431, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4432, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4433, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4434, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4435, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4436, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4437, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4441, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4442, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4443, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4459, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(4460, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4461, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4462, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4463, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4464, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4465, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4466, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4467, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4471, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(4472, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4473, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4477, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(4478, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4479, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4480, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(4481, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4482, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4486, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(4487, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(4488, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(4489, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4490, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4491, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4492, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4493, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4494, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4495, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4496, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4497, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4501, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4502, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4503, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4504, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4505, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4506, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4507, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4508, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4509, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4510, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4511, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4512, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4516, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4517, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4518, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4534, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(4535, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(4536, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(4537, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4538, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4539, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4540, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4541, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4542, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4546, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(4547, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(4548, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(4549, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(4550, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \
+       _(4551, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(4552, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED) \
+       _(4553, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(4554, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \
+       _(4555, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(4556, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \
+       _(4557, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(4558, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED) \
+       _(4559, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(4560, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \
+       _(4561, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \
+       _(4562, ZEND_POST_INC_LONG_SPEC_TMPVARCV) \
+       _(4563, ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \
+       _(4564, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \
+       _(4565, ZEND_POST_DEC_LONG_SPEC_TMPVARCV) \
+       _(4566, ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \
+       _(4567, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \
+       _(4568, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+       _(4569, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+       _(4571, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+       _(4572, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \
+       _(4573, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+       _(4574, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+       _(4576, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+       _(4578, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+       _(4579, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+       _(4581, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+       _(4582, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
+       _(4583, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(4584, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(4586, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(4587, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
+       _(4588, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(4589, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(4591, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(4597, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \
+       _(4598, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+       _(4599, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+       _(4601, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+       _(4604, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \
+       _(4606, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \
+       _(4609, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \
+       _(4611, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \
+       _(4612, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \
+       _(4613, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \
+       _(4614, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \
+       _(4615, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \
+       _(4615+1, ZEND_NULL)

diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c
index 12d8fa8d679b8092582b26fcc4b5f64a338b9fb4..b821fcbc8f490c71034443516d5facbd9ca82276 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[200] = {
+static const char *zend_vm_opcodes_names[207] = {
        "ZEND_NOP",
        "ZEND_ADD",
        "ZEND_SUB",
@@ -223,9 +223,16 @@ static const char *zend_vm_opcodes_names[200] = {
        "ZEND_ISSET_ISEMPTY_CV",
        "ZEND_FETCH_LIST_W",
        "ZEND_ARRAY_KEY_EXISTS",
+       "ZEND_ASSIGN_OBJ_REF",
+       "ZEND_ASSIGN_STATIC_PROP",
+       "ZEND_ASSIGN_STATIC_PROP_REF",
+       "ZEND_PRE_INC_STATIC_PROP",
+       "ZEND_PRE_DEC_STATIC_PROP",
+       "ZEND_POST_INC_STATIC_PROP",
+       "ZEND_POST_DEC_STATIC_PROP",
 };
 
-static uint32_t zend_vm_opcodes_flags[200] = {
+static uint32_t zend_vm_opcodes_flags[207] = {
        0x00000000,
        0x00000707,
        0x00000707,
@@ -249,17 +256,17 @@ static uint32_t zend_vm_opcodes_flags[200] = {
        0x00000707,
        0x07000003,
        0x00000003,
-       0x04046751,
-       0x04046751,
-       0x04046751,
-       0x04046751,
-       0x04046751,
-       0x04046751,
-       0x04046751,
-       0x04046751,
-       0x04046751,
-       0x04046751,
-       0x04046751,
+       0x04046753,
+       0x04046753,
+       0x04046753,
+       0x04046753,
+       0x04046753,
+       0x04046753,
+       0x04046753,
+       0x04046753,
+       0x04046753,
+       0x04046753,
+       0x04046753,
        0x00000001,
        0x00000001,
        0x00000001,
@@ -311,7 +318,7 @@ static uint32_t zend_vm_opcodes_flags[200] = {
        0x00040757,
        0x00010107,
        0x00006701,
-       0x00040751,
+       0x00640751,
        0x00010107,
        0x00006701,
        0x00040751,
@@ -320,7 +327,7 @@ static uint32_t zend_vm_opcodes_flags[200] = {
        0x00040757,
        0x00010107,
        0x00006703,
-       0x00040753,
+       0x00240753,
        0x00010107,
        0x00000701,
        0x00040751,
@@ -393,17 +400,17 @@ static uint32_t zend_vm_opcodes_flags[200] = {
        0x0000a110,
        0x00000000,
        0x00000707,
-       0x04046751,
+       0x04046753,
        0x00040301,
        0x00002007,
        0x00000707,
        0x03000000,
        0x03000303,
        0x00047307,
+       0x00647307,
        0x00047307,
        0x00047307,
-       0x00047307,
-       0x00047307,
+       0x00247307,
        0x00047307,
        0x00047307,
        0x00067307,
@@ -426,6 +433,13 @@ static uint32_t zend_vm_opcodes_flags[200] = {
        0x00020101,
        0x00000701,
        0x00000707,
+       0x0b040751,
+       0x00040307,
+       0x0b040307,
+       0x00040307,
+       0x00040307,
+       0x00040307,
+       0x00040307,
 };
 
 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 922377b72b564957e59e87984dfd3caa9a605dcd..c4c9c1c58302e694c81d54cf05f3ab7df1a18142 100644 (file)
--- a/Zend/zend_vm_opcodes.h
+++ b/Zend/zend_vm_opcodes.h
@@ -53,6 +53,8 @@
 #define ZEND_VM_EXT_CACHE_SLOT   0x00040000
 #define ZEND_VM_EXT_ARRAY_INIT   0x00080000
 #define ZEND_VM_EXT_REF          0x00100000
+#define ZEND_VM_EXT_FETCH_REF    0x00200000
+#define ZEND_VM_EXT_DIM_OBJ_WRITE 0x00400000
 #define ZEND_VM_EXT_MASK         0x0f000000
 #define ZEND_VM_EXT_NUM          0x01000000
 #define ZEND_VM_EXT_LAST_CATCH   0x02000000
@@ -270,7 +272,14 @@ END_EXTERN_C()
 #define ZEND_ISSET_ISEMPTY_CV                197
 #define ZEND_FETCH_LIST_W                    198
 #define ZEND_ARRAY_KEY_EXISTS                199
+#define ZEND_ASSIGN_OBJ_REF                  200
+#define ZEND_ASSIGN_STATIC_PROP              201
+#define ZEND_ASSIGN_STATIC_PROP_REF          202
+#define ZEND_PRE_INC_STATIC_PROP             203
+#define ZEND_PRE_DEC_STATIC_PROP             204
+#define ZEND_POST_INC_STATIC_PROP            205
+#define ZEND_POST_DEC_STATIC_PROP            206
 
-#define ZEND_VM_LAST_OPCODE                  199
+#define ZEND_VM_LAST_OPCODE                  206
 
 #endif

diff --git a/ext/com_dotnet/com_handlers.c b/ext/com_dotnet/com_handlers.c
index 9c58732e0b41a9aaabbde20987de364818a1376b..fd70a98ef7b29446e927ec021c29c82e0d494374 100644 (file)
--- a/ext/com_dotnet/com_handlers.c
+++ b/ext/com_dotnet/com_handlers.c
@@ -58,7 +58,7 @@ static zval *com_property_read(zval *object, zval *member, int type, void **cahc
        return rv;
 }
 
-static void com_property_write(zval *object, zval *member, zval *value, void **cache_slot)
+static zval *com_property_write(zval *object, zval *member, zval *value, void **cache_slot)
 {
        php_com_dotnet_object *obj;
        VARIANT v;
@@ -76,6 +76,7 @@ static void com_property_write(zval *object, zval *member, zval *value, void **c
        } else {
                php_com_throw_exception(E_INVALIDARG, "this variant has no properties");
        }
+       return value;
 }
 
 static zval *com_read_dimension(zval *object, zval *offset, int type, zval *rv)

diff --git a/ext/com_dotnet/com_saproxy.c b/ext/com_dotnet/com_saproxy.c
index e5b390bca6bb8fc3c3cadb737e487a5a98544969..abdca0433494c4eb49d73b356f8aa50941e13d07 100644 (file)
--- a/ext/com_dotnet/com_saproxy.c
+++ b/ext/com_dotnet/com_saproxy.c
@@ -69,7 +69,7 @@ static inline void clone_indices(php_com_saproxy *dest, php_com_saproxy *src, in
        }
 }
 
-static zval *saproxy_property_read(zval *object, zval *member, int type, void **cahce_slot, zval *rv)
+static zval *saproxy_property_read(zval *object, zval *member, int type, void **cache_slot, zval *rv)
 {
        ZVAL_NULL(rv);
 

diff --git a/ext/curl/multi.c b/ext/curl/multi.c
index cacda1aef449497a88ebd69b046910d8c2ef7301..1a891a4ebc2c2754468519cd196fa6ce7bd9deb2 100644 (file)
--- a/ext/curl/multi.c
+++ b/ext/curl/multi.c
@@ -265,7 +265,7 @@ PHP_FUNCTION(curl_multi_exec)
 
        ZEND_PARSE_PARAMETERS_START(2, 2)
                Z_PARAM_RESOURCE(z_mh)
-               Z_PARAM_ZVAL_DEREF(z_still_running)
+               Z_PARAM_ZVAL(z_still_running)
        ZEND_PARSE_PARAMETERS_END();
 
        if ((mh = (php_curlm *)zend_fetch_resource(Z_RES_P(z_mh), le_curl_multi_handle_name, le_curl_multi_handle)) == NULL) {
@@ -290,8 +290,7 @@ PHP_FUNCTION(curl_multi_exec)
 
        still_running = zval_get_long(z_still_running);
        error = curl_multi_perform(mh->multi, &still_running);
-       zval_ptr_dtor(z_still_running);
-       ZVAL_LONG(z_still_running, still_running);
+       ZEND_TRY_ASSIGN_LONG(z_still_running, still_running);
 
        SAVE_CURLM_ERROR(mh, error);
        RETURN_LONG((zend_long) error);
@@ -338,7 +337,7 @@ PHP_FUNCTION(curl_multi_info_read)
        ZEND_PARSE_PARAMETERS_START(1, 2)
                Z_PARAM_RESOURCE(z_mh)
                Z_PARAM_OPTIONAL
-               Z_PARAM_ZVAL_DEREF(zmsgs_in_queue)
+               Z_PARAM_ZVAL(zmsgs_in_queue)
        ZEND_PARSE_PARAMETERS_END();
 
        if ((mh = (php_curlm *)zend_fetch_resource(Z_RES_P(z_mh), le_curl_multi_handle_name, le_curl_multi_handle)) == NULL) {
@@ -349,9 +348,9 @@ PHP_FUNCTION(curl_multi_info_read)
        if (tmp_msg == NULL) {
                RETURN_FALSE;
        }
+
        if (zmsgs_in_queue) {
-               zval_ptr_dtor(zmsgs_in_queue);
-               ZVAL_LONG(zmsgs_in_queue, queued_msgs);
+               ZEND_TRY_ASSIGN_LONG(zmsgs_in_queue, queued_msgs);
        }
 
        array_init(return_value);

diff --git a/ext/date/php_date.c b/ext/date/php_date.c
index f40ec15e0700afb19787ea7e7dae38a7954cdfdc..eb56deb558177a078bcd1db3e082309da4e29469 100644 (file)
--- a/ext/date/php_date.c
+++ b/ext/date/php_date.c
@@ -660,10 +660,10 @@ static HashTable *date_object_get_debug_info_timezone(zval *object, int *is_temp
 static void php_timezone_to_string(php_timezone_obj *tzobj, zval *zv);
 
 zval *date_interval_read_property(zval *object, zval *member, int type, void **cache_slot, zval *rv);
-void date_interval_write_property(zval *object, zval *member, zval *value, void **cache_slot);
+zval *date_interval_write_property(zval *object, zval *member, zval *value, void **cache_slot);
 static zval *date_interval_get_property_ptr_ptr(zval *object, zval *member, int type, void **cache_slot);
 static zval *date_period_read_property(zval *object, zval *member, int type, void **cache_slot, zval *rv);
-static void date_period_write_property(zval *object, zval *member, zval *value, void **cache_slot);
+static zval *date_period_write_property(zval *object, zval *member, zval *value, void **cache_slot);
 
 /* {{{ Module struct */
 zend_module_entry date_module_entry = {
@@ -4211,7 +4211,7 @@ zval *date_interval_read_property(zval *object, zval *member, int type, void **c
 /* }}} */
 
 /* {{{ date_interval_write_property */
-void date_interval_write_property(zval *object, zval *member, zval *value, void **cache_slot)
+zval *date_interval_write_property(zval *object, zval *member, zval *value, void **cache_slot)
 {
        php_interval_obj *obj;
        zval tmp_member;
@@ -4225,17 +4225,17 @@ void date_interval_write_property(zval *object, zval *member, zval *value, void
        obj = Z_PHPINTERVAL_P(object);
 
        if (!obj->initialized) {
-               zend_std_write_property(object, member, value, cache_slot);
+               value = zend_std_write_property(object, member, value, cache_slot);
                if (member == &tmp_member) {
                        zval_ptr_dtor_str(&tmp_member);
                }
-               return;
+               return value;
        }
 
 #define SET_VALUE_FROM_STRUCT(n,m)            \
        if (strcmp(Z_STRVAL_P(member), m) == 0) { \
                obj->diff->n = zval_get_long(value); \
-               break;                                                            \
+               break; \
        }
 
        do {
@@ -4251,12 +4251,14 @@ void date_interval_write_property(zval *object, zval *member, zval *value, void
                }
                SET_VALUE_FROM_STRUCT(invert, "invert");
                /* didn't find any */
-               zend_std_write_property(object, member, value, cache_slot);
+               value = zend_std_write_property(object, member, value, cache_slot);
        } while(0);
 
        if (member == &tmp_member) {
                zval_ptr_dtor_str(&tmp_member);
        }
+
+       return value;
 }
 /* }}} */
 
@@ -5295,9 +5297,10 @@ static zval *date_period_read_property(zval *object, zval *member, int type, voi
 /* }}} */
 
 /* {{{ date_period_write_property */
-static void date_period_write_property(zval *object, zval *member, zval *value, void **cache_slot)
+static zval *date_period_write_property(zval *object, zval *member, zval *value, void **cache_slot)
 {
        zend_throw_error(NULL, "Writing to DatePeriod properties is unsupported");
+       return value;
 }
 /* }}} */
 

diff --git a/ext/date/tests/DateInterval_write_property_return.phpt b/ext/date/tests/DateInterval_write_property_return.phpt
new file mode 100644 (file)
index 0000000..9c2c5c9
--- /dev/null
+++ b/ext/date/tests/DateInterval_write_property_return.phpt
@@ -0,0 +1,14 @@
+--TEST--
+Test that return value handling for DateInterval property writes do not corrupt RHS
+--FILE--
+<?php
+
+$interval = new DateInterval('P2Y4DT6H8M');
+$f = 0.5;
+var_dump($interval->f = $f);
+var_dump($f);
+
+?>
+--EXPECT--
+float(0.5)
+float(0.5)

diff --git a/ext/dom/php_dom.c b/ext/dom/php_dom.c
index 72ae3c3ffea36ef952a32739e8f074cd0deb2b19..a25a185e012d12d3bb2e0fa692f38404efef7d83 100644 (file)
--- a/ext/dom/php_dom.c
+++ b/ext/dom/php_dom.c
@@ -356,7 +356,7 @@ zval *dom_read_property(zval *object, zval *member, int type, void **cache_slot,
 /* }}} */
 
 /* {{{ dom_write_property */
-void dom_write_property(zval *object, zval *member, zval *value, void **cache_slot)
+zval *dom_write_property(zval *object, zval *member, zval *value, void **cache_slot)
 {
        dom_object *obj = Z_DOMOBJ_P(object);
        zend_string *member_str = zval_get_string(member);
@@ -368,10 +368,12 @@ void dom_write_property(zval *object, zval *member, zval *value, void **cache_sl
        if (hnd) {
                hnd->write_func(obj, value);
        } else {
-               zend_std_write_property(object, member, value, cache_slot);
+               value = zend_std_write_property(object, member, value, cache_slot);
        }
 
        zend_string_release_ex(member_str, 0);
+
+       return value;
 }
 /* }}} */
 

diff --git a/ext/enchant/enchant.c b/ext/enchant/enchant.c
index 6b778092f93ac739d0d344738a5c56d5649cf9b3..595d41e9d45d25ab345856bbe173393985c1bb9b 100644 (file)
--- a/ext/enchant/enchant.c
+++ b/ext/enchant/enchant.c
@@ -711,13 +711,15 @@ PHP_FUNCTION(enchant_dict_quick_check)
        size_t wordlen;
        enchant_dict *pdict;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs|z/", &dict, &word, &wordlen, &sugg) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs|z", &dict, &word, &wordlen, &sugg) == FAILURE) {
                RETURN_FALSE;
        }
 
        if (sugg) {
-               zval_ptr_dtor(sugg);
-               array_init(sugg);
+               sugg = zend_try_array_init(sugg);
+               if (!sugg) {
+                       return;
+               }
        }
 
        PHP_ENCHANT_GET_DICT;

diff --git a/ext/exif/exif.c b/ext/exif/exif.c
index 48e937216194fc030561001126af538212197626..d37a61f83da7bd8c14eeaa0d14762e3a4e7c80e6 100644 (file)
--- a/ext/exif/exif.c
+++ b/ext/exif/exif.c
@@ -4606,9 +4606,9 @@ PHP_FUNCTION(exif_thumbnail)
        ZEND_PARSE_PARAMETERS_START(1, 4)
                Z_PARAM_ZVAL(stream)
                Z_PARAM_OPTIONAL
-               Z_PARAM_ZVAL_DEREF(z_width)
-               Z_PARAM_ZVAL_DEREF(z_height)
-               Z_PARAM_ZVAL_DEREF(z_imagetype)
+               Z_PARAM_ZVAL(z_width)
+               Z_PARAM_ZVAL(z_height)
+               Z_PARAM_ZVAL(z_imagetype)
        ZEND_PARSE_PARAMETERS_END();
 
        memset(&ImageInfo, 0, sizeof(ImageInfo));
@@ -4653,14 +4653,11 @@ PHP_FUNCTION(exif_thumbnail)
                if (!ImageInfo.Thumbnail.width || !ImageInfo.Thumbnail.height) {
                        exif_scan_thumbnail(&ImageInfo);
                }
-               zval_ptr_dtor(z_width);
-               zval_ptr_dtor(z_height);
-               ZVAL_LONG(z_width,  ImageInfo.Thumbnail.width);
-               ZVAL_LONG(z_height, ImageInfo.Thumbnail.height);
+               ZEND_TRY_ASSIGN_LONG(z_width,  ImageInfo.Thumbnail.width);
+               ZEND_TRY_ASSIGN_LONG(z_height, ImageInfo.Thumbnail.height);
        }
        if (arg_c >= 4) {
-               zval_ptr_dtor(z_imagetype);
-               ZVAL_LONG(z_imagetype, ImageInfo.Thumbnail.filetype);
+               ZEND_TRY_ASSIGN_LONG(z_imagetype, ImageInfo.Thumbnail.filetype);
        }
 
 #ifdef EXIF_DEBUG

diff --git a/ext/ftp/php_ftp.c b/ext/ftp/php_ftp.c
index 4b3a0fb3066a685383a5ec9343944b117034b4b2..5be151cb59a4d889cbff248836cd45a79150a124 100644 (file)
--- a/ext/ftp/php_ftp.c
+++ b/ext/ftp/php_ftp.c
@@ -677,7 +677,7 @@ PHP_FUNCTION(ftp_alloc)
        zend_long               size, ret;
        zend_string     *response = NULL;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rl|z/", &z_ftp, &size, &zresponse) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rl|z", &z_ftp, &size, &zresponse) == FAILURE) {
                RETURN_FALSE;
        }
 
@@ -686,9 +686,9 @@ PHP_FUNCTION(ftp_alloc)
        }
 
        ret = ftp_alloc(ftp, size, zresponse ? &response : NULL);
+
        if (response) {
-               zval_ptr_dtor(zresponse);
-               ZVAL_STR(zresponse, response);
+               ZEND_TRY_ASSIGN_STR(zresponse, response);
        }
 
        if (!ret) {

diff --git a/ext/intl/formatter/formatter_parse.c b/ext/intl/formatter/formatter_parse.c
index 347f929cbd5b3178ca308210b6681c4704dbf2d7..4ee14b3ce3658f5446773e051628009fa3950765 100644 (file)
--- a/ext/intl/formatter/formatter_parse.c
+++ b/ext/intl/formatter/formatter_parse.c
@@ -51,7 +51,7 @@ PHP_FUNCTION( numfmt_parse )
        FORMATTER_METHOD_INIT_VARS;
 
        /* Parse parameters. */
-       if( zend_parse_method_parameters( ZEND_NUM_ARGS(), getThis(), "Os|lz/!",
+       if( zend_parse_method_parameters( ZEND_NUM_ARGS(), getThis(), "Os|lz!",
                &object, NumberFormatter_ce_ptr,  &str, &str_len, &type, &zposition ) == FAILURE )
        {
                intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
@@ -60,6 +60,11 @@ PHP_FUNCTION( numfmt_parse )
                RETURN_FALSE;
        }
 
+       if(zposition) {
+               position = (int32_t) zval_get_long(zposition);
+               position_p = &position;
+       }
+
        /* Fetch the object. */
        FORMATTER_METHOD_FETCH_OBJECT;
 
@@ -67,12 +72,6 @@ PHP_FUNCTION( numfmt_parse )
        intl_convert_utf8_to_utf16(&sstr, &sstr_len, str, str_len, &INTL_DATA_ERROR_CODE(nfo));
        INTL_METHOD_CHECK_STATUS( nfo, "String conversion to UTF-16 failed" );
 
-       if(zposition) {
-               ZVAL_DEREF(zposition);
-               position = (int32_t)zval_get_long( zposition );
-               position_p = &position;
-       }
-
 #if ICU_LOCALE_BUG && defined(LC_NUMERIC)
        /* need to copy here since setlocale may change it later */
        oldlocale = estrdup(setlocale(LC_NUMERIC, NULL));
@@ -106,8 +105,7 @@ PHP_FUNCTION( numfmt_parse )
        efree(oldlocale);
 #endif
        if(zposition) {
-               zval_ptr_dtor(zposition);
-               ZVAL_LONG(zposition, position);
+               ZEND_TRY_ASSIGN_LONG(zposition, position);
        }
 
        if (sstr) {
@@ -138,7 +136,7 @@ PHP_FUNCTION( numfmt_parse_currency )
        FORMATTER_METHOD_INIT_VARS;
 
        /* Parse parameters. */
-       if( zend_parse_method_parameters( ZEND_NUM_ARGS(), getThis(), "Osz/|z/!",
+       if( zend_parse_method_parameters( ZEND_NUM_ARGS(), getThis(), "Osz/|z!",
                &object, NumberFormatter_ce_ptr,  &str, &str_len, &zcurrency, &zposition ) == FAILURE )
        {
                intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR,
@@ -155,15 +153,13 @@ PHP_FUNCTION( numfmt_parse_currency )
        INTL_METHOD_CHECK_STATUS( nfo, "String conversion to UTF-16 failed" );
 
        if(zposition) {
-               ZVAL_DEREF(zposition);
-               position = (int32_t)zval_get_long( zposition );
+               position = (int32_t) zval_get_long(zposition);
                position_p = &position;
        }
 
        number = unum_parseDoubleCurrency(FORMATTER_OBJECT(nfo), sstr, sstr_len, position_p, currency, &INTL_DATA_ERROR_CODE(nfo));
        if(zposition) {
-               zval_ptr_dtor(zposition);
-               ZVAL_LONG(zposition, position);
+               ZEND_TRY_ASSIGN_LONG(zposition, position);
        }
        if (sstr) {
                efree(sstr);

diff --git a/ext/intl/idn/idn.c b/ext/intl/idn/idn.c
index 305a944cce25ee0b11956b822f53b58850dd68b5..d717d46ee2076810104a9052bac7f64a380738c1 100644 (file)
--- a/ext/intl/idn/idn.c
+++ b/ext/intl/idn/idn.c
@@ -259,7 +259,7 @@ static void php_intl_idn_handoff(INTERNAL_FUNCTION_PARAMETERS, int mode)
 
        intl_error_reset(NULL);
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|llz/",
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|llz",
                        &domain, &option, &variant, &idna_info) == FAILURE) {
                php_intl_bad_args("bad arguments");
                RETURN_NULL(); /* don't set FALSE because that's not the way it was before... */
@@ -291,8 +291,10 @@ static void php_intl_idn_handoff(INTERNAL_FUNCTION_PARAMETERS, int mode)
                                "4 arguments were provided, but INTL_IDNA_VARIANT_2003 only "
                                "takes 3 - extra argument ignored");
                } else {
-                       zval_ptr_dtor(idna_info);
-                       array_init(idna_info);
+                       idna_info = zend_try_array_init(idna_info);
+                       if (!idna_info) {
+                               return;
+                       }
                }
        }
 

diff --git a/ext/intl/transliterator/transliterator_class.c b/ext/intl/transliterator/transliterator_class.c
index e06ebd5c2595b55be9a01d9648e1657f7415b5cc..0f5d8cbf21df56bef7ff72baa22d7601e0e04cda 100644 (file)
--- a/ext/intl/transliterator/transliterator_class.c
+++ b/ext/intl/transliterator/transliterator_class.c
@@ -255,8 +255,7 @@ static zval *Transliterator_read_property( zval *object, zval *member, int type,
 /* }}} */
 
 /* {{{ write_property handler */
-static void Transliterator_write_property( zval *object, zval *member, zval *value,
-       void **cache_slot )
+static zval *Transliterator_write_property( zval *object, zval *member, zval *value, void **cache_slot )
 {
        zend_class_entry *scope;
        TRANSLITERATOR_PROPERTY_HANDLER_PROLOG;
@@ -274,10 +273,12 @@ static void Transliterator_write_property( zval *object, zval *member, zval *val
        }
        else
        {
-               zend_std_write_property( object, member, value, cache_slot );
+               value = zend_std_write_property( object, member, value, cache_slot );
        }
 
        TRANSLITERATOR_PROPERTY_HANDLER_EPILOG;
+
+       return value;
 }
 /* }}} */
 

diff --git a/ext/ldap/ldap.c b/ext/ldap/ldap.c
index 1ddf1a77ca7b9331f51c38e5da6b2f3b21e82231..0528ea08d77d4d088304a956bc6f0f58792f53da 100644 (file)
--- a/ext/ldap/ldap.c
+++ b/ext/ldap/ldap.c
@@ -576,7 +576,11 @@ static void _php_ldap_controls_to_array(LDAP *ld, LDAPControl** ctrls, zval* arr
        zval tmp1;
        LDAPControl **ctrlp;
 
-       array_init(array);
+       array = zend_try_array_init(array);
+       if (!array) {
+               return;
+       }
+
        if (ctrls == NULL) {
                return;
        }
@@ -2975,7 +2979,7 @@ PHP_FUNCTION(ldap_get_option)
        ldap_linkdata *ld;
        zend_long option;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rlz/", &link, &option, &retval) != SUCCESS) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rlz", &link, &option, &retval) != SUCCESS) {
                return;
        }
 
@@ -3017,8 +3021,7 @@ PHP_FUNCTION(ldap_get_option)
                        if (ldap_get_option(ld->link, option, &val)) {
                                RETURN_FALSE;
                        }
-                       zval_ptr_dtor(retval);
-                       ZVAL_LONG(retval, val);
+                       ZEND_TRY_ASSIGN_LONG(retval, val);
                } break;
 #ifdef LDAP_OPT_NETWORK_TIMEOUT
        case LDAP_OPT_NETWORK_TIMEOUT:
@@ -3034,8 +3037,7 @@ PHP_FUNCTION(ldap_get_option)
                        if (!timeout) {
                                RETURN_FALSE;
                        }
-                       zval_ptr_dtor(retval);
-                       ZVAL_LONG(retval, timeout->tv_sec);
+                       ZEND_TRY_ASSIGN_LONG(retval, timeout->tv_sec);
                        ldap_memfree(timeout);
                } break;
 #elif defined(LDAP_X_OPT_CONNECT_TIMEOUT)
@@ -3046,8 +3048,7 @@ PHP_FUNCTION(ldap_get_option)
                        if (ldap_get_option(ld->link, LDAP_X_OPT_CONNECT_TIMEOUT, &timeout)) {
                                RETURN_FALSE;
                        }
-                       zval_ptr_dtor(retval);
-                       ZVAL_LONG(retval, (timeout / 1000));
+                       ZEND_TRY_ASSIGN_LONG(retval, (timeout / 1000));
                } break;
 #endif
 #ifdef LDAP_OPT_TIMEOUT
@@ -3064,8 +3065,7 @@ PHP_FUNCTION(ldap_get_option)
                        if (!timeout) {
                                RETURN_FALSE;
                        }
-                       zval_ptr_dtor(retval);
-                       ZVAL_LONG(retval, timeout->tv_sec);
+                       ZEND_TRY_ASSIGN_LONG(retval, timeout->tv_sec);
                        ldap_memfree(timeout);
                } break;
 #endif
@@ -3112,8 +3112,7 @@ PHP_FUNCTION(ldap_get_option)
                                }
                                RETURN_FALSE;
                        }
-                       zval_ptr_dtor(retval);
-                       ZVAL_STRING(retval, val);
+                       ZEND_TRY_ASSIGN_STRING(retval, val);
                        ldap_memfree(val);
                } break;
        case LDAP_OPT_SERVER_CONTROLS:
@@ -3333,7 +3332,7 @@ PHP_FUNCTION(ldap_parse_result)
        char *lmatcheddn, *lerrmsg;
        int rc, lerrcode, myargcount = ZEND_NUM_ARGS();
 
-       if (zend_parse_parameters(myargcount, "rrz/|z/z/z/z/", &link, &result, &errcode, &matcheddn, &errmsg, &referrals, &serverctrls) != SUCCESS) {
+       if (zend_parse_parameters(myargcount, "rrz|zzzz", &link, &result, &errcode, &matcheddn, &errmsg, &referrals, &serverctrls) != SUCCESS) {
                return;
        }
 
@@ -3356,16 +3355,17 @@ PHP_FUNCTION(ldap_parse_result)
                RETURN_FALSE;
        }
 
-       zval_ptr_dtor(errcode);
-       ZVAL_LONG(errcode, lerrcode);
+       ZEND_TRY_ASSIGN_LONG(errcode, lerrcode);
 
        /* Reverse -> fall through */
        switch (myargcount) {
                case 7:
                        _php_ldap_controls_to_array(ld->link, lserverctrls, serverctrls, 0);
                case 6:
-                       zval_ptr_dtor(referrals);
-                       array_init(referrals);
+                       referrals = zend_try_array_init(referrals);
+                       if (!referrals) {
+                               return;
+                       }
                        if (lreferrals != NULL) {
                                refp = lreferrals;
                                while (*refp) {
@@ -3375,19 +3375,17 @@ PHP_FUNCTION(ldap_parse_result)
                                ldap_memvfree((void**)lreferrals);
                        }
                case 5:
-                       zval_ptr_dtor(errmsg);
                        if (lerrmsg == NULL) {
-                               ZVAL_EMPTY_STRING(errmsg);
+                               ZEND_TRY_ASSIGN_EMPTY_STRING(errmsg);
                        } else {
-                               ZVAL_STRING(errmsg, lerrmsg);
+                               ZEND_TRY_ASSIGN_STRING(errmsg, lerrmsg);
                                ldap_memfree(lerrmsg);
                        }
                case 4:
-                       zval_ptr_dtor(matcheddn);
                        if (lmatcheddn == NULL) {
-                               ZVAL_EMPTY_STRING(matcheddn);
+                               ZEND_TRY_ASSIGN_EMPTY_STRING(matcheddn);
                        } else {
-                               ZVAL_STRING(matcheddn, lmatcheddn);
+                               ZEND_TRY_ASSIGN_STRING(matcheddn, lmatcheddn);
                                ldap_memfree(lmatcheddn);
                        }
        }
@@ -3398,7 +3396,7 @@ PHP_FUNCTION(ldap_parse_result)
 
 /* {{{ Extended operation response parsing, Pierangelo Masarati */
 #ifdef HAVE_LDAP_PARSE_EXTENDED_RESULT
-/* {{{ proto bool ldap_parse_exop(resource link, resource result [, string retdata [, string retoid]])
+/* {{{ proto bool ldap_parse_exop(resource link, resource result [, string &retdata [, string &retoid]])
    Extract information from extended operation result */
 PHP_FUNCTION(ldap_parse_exop)
 {
@@ -3409,7 +3407,7 @@ PHP_FUNCTION(ldap_parse_exop)
        struct berval *lretdata;
        int rc, myargcount = ZEND_NUM_ARGS();
 
-       if (zend_parse_parameters(myargcount, "rr|z/z/", &link, &result, &retdata, &retoid) != SUCCESS) {
+       if (zend_parse_parameters(myargcount, "rr|zz", &link, &result, &retdata, &retoid) != SUCCESS) {
                WRONG_PARAM_COUNT;
        }
 
@@ -3433,20 +3431,18 @@ PHP_FUNCTION(ldap_parse_exop)
        /* Reverse -> fall through */
        switch (myargcount) {
                case 4:
-                       zval_ptr_dtor(retoid);
                        if (lretoid == NULL) {
-                               ZVAL_EMPTY_STRING(retoid);
+                               ZEND_TRY_ASSIGN_EMPTY_STRING(retoid);
                        } else {
-                               ZVAL_STRING(retoid, lretoid);
+                               ZEND_TRY_ASSIGN_STRING(retoid, lretoid);
                                ldap_memfree(lretoid);
                        }
                case 3:
                        /* use arg #3 as the data returned by the server */
-                       zval_ptr_dtor(retdata);
                        if (lretdata == NULL) {
-                               ZVAL_EMPTY_STRING(retdata);
+                               ZEND_TRY_ASSIGN_EMPTY_STRING(retdata);
                        } else {
-                               ZVAL_STRINGL(retdata, lretdata->bv_val, lretdata->bv_len);
+                               ZEND_TRY_ASSIGN_STRINGL(retdata, lretdata->bv_val, lretdata->bv_len);
                                ldap_memfree(lretdata->bv_val);
                                ldap_memfree(lretdata);
                        }
@@ -3524,7 +3520,7 @@ PHP_FUNCTION(ldap_next_reference)
 /* }}} */
 
 #ifdef HAVE_LDAP_PARSE_REFERENCE
-/* {{{ proto bool ldap_parse_reference(resource link, resource reference_entry, array referrals)
+/* {{{ proto bool ldap_parse_reference(resource link, resource reference_entry, array &referrals)
    Extract information from reference entry */
 PHP_FUNCTION(ldap_parse_reference)
 {
@@ -3533,7 +3529,7 @@ PHP_FUNCTION(ldap_parse_reference)
        ldap_resultentry *resultentry;
        char **lreferrals, **refp;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rrz/", &link, &result_entry, &referrals) != SUCCESS) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rrz", &link, &result_entry, &referrals) != SUCCESS) {
                return;
        }
 
@@ -3549,8 +3545,11 @@ PHP_FUNCTION(ldap_parse_reference)
                RETURN_FALSE;
        }
 
-       zval_ptr_dtor(referrals);
-       array_init(referrals);
+       referrals = zend_try_array_init(referrals);
+       if (!referrals) {
+               return;
+       }
+
        if (lreferrals != NULL) {
                refp = lreferrals;
                while (*refp) {
@@ -4015,7 +4014,7 @@ PHP_FUNCTION(ldap_control_paged_result_response)
        ber_tag_t tag;
        int rc, lerrcode, myargcount = ZEND_NUM_ARGS();
 
-       if (zend_parse_parameters(myargcount, "rr|z/z/", &link, &result, &cookie, &estimated) != SUCCESS) {
+       if (zend_parse_parameters(myargcount, "rr|zz", &link, &result, &cookie, &estimated) != SUCCESS) {
                return;
        }
 
@@ -4082,15 +4081,13 @@ PHP_FUNCTION(ldap_control_paged_result_response)
 
        ldap_controls_free(lserverctrls);
        if (myargcount == 4) {
-               zval_ptr_dtor(estimated);
-               ZVAL_LONG(estimated, lestimated);
+               ZEND_TRY_ASSIGN_LONG(estimated, lestimated);
        }
 
-       zval_ptr_dtor(cookie);
        if (lcookie.bv_len == 0) {
-               ZVAL_EMPTY_STRING(cookie);
+               ZEND_TRY_ASSIGN_EMPTY_STRING(cookie);
        } else {
-               ZVAL_STRINGL(cookie, lcookie.bv_val, lcookie.bv_len);
+               ZEND_TRY_ASSIGN_STRINGL(cookie, lcookie.bv_val, lcookie.bv_len);
        }
        ldap_memfree(lcookie.bv_val);
 
@@ -4115,7 +4112,7 @@ PHP_FUNCTION(ldap_exop)
        LDAPControl **lserverctrls = NULL;
        int rc, msgid;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rS|S!a!z/z/", &link, &reqoid, &reqdata, &serverctrls, &retdata, &retoid) != SUCCESS) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rS|S!a!zz", &link, &reqoid, &reqdata, &serverctrls, &retdata, &retoid) != SUCCESS) {
                return;
        }
 
@@ -4153,22 +4150,20 @@ PHP_FUNCTION(ldap_exop)
                }
 
                if (retoid) {
-                       zval_ptr_dtor(retoid);
                        if (lretoid) {
-                               ZVAL_STRING(retoid, lretoid);
+                               ZEND_TRY_ASSIGN_STRING(retoid, lretoid);
                                ldap_memfree(lretoid);
                        } else {
-                               ZVAL_EMPTY_STRING(retoid);
+                               ZEND_TRY_ASSIGN_EMPTY_STRING(retoid);
                        }
                }
 
-               zval_ptr_dtor(retdata);
                if (lretdata) {
-                       ZVAL_STRINGL(retdata, lretdata->bv_val, lretdata->bv_len);
+                       ZEND_TRY_ASSIGN_STRINGL(retdata, lretdata->bv_val, lretdata->bv_len);
                        ldap_memfree(lretdata->bv_val);
                        ldap_memfree(lretdata);
                } else {
-                       ZVAL_EMPTY_STRING(retdata);
+                       ZEND_TRY_ASSIGN_EMPTY_STRING(retdata);
                }
 
                RETVAL_TRUE;
@@ -4219,7 +4214,7 @@ PHP_FUNCTION(ldap_exop_passwd)
        int rc, myargcount = ZEND_NUM_ARGS(), msgid, err;
        char* errmsg;
 
-       if (zend_parse_parameters(myargcount, "r|zzzz/", &link, &user, &oldpw, &newpw, &serverctrls) == FAILURE) {
+       if (zend_parse_parameters(myargcount, "r|zzzz", &link, &user, &oldpw, &newpw, &serverctrls) == FAILURE) {
                WRONG_PARAM_COUNT;
        }
 

diff --git a/ext/mbstring/mbstring.c b/ext/mbstring/mbstring.c
index cdca12b00ee0d551b824fd21a1298de4f5665729..264c6020cab41275447125a8d8b4ab06eba05f27 100644 (file)
--- a/ext/mbstring/mbstring.c
+++ b/ext/mbstring/mbstring.c
@@ -2131,14 +2131,15 @@ PHP_FUNCTION(mb_parse_str)
        const mbfl_encoding *detected;
 
        track_vars_array = NULL;
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|z/", &encstr, &encstr_len, &track_vars_array) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|z", &encstr, &encstr_len, &track_vars_array) == FAILURE) {
                return;
        }
 
        if (track_vars_array != NULL) {
-               /* Clear out the array */
-               zval_ptr_dtor(track_vars_array);
-               array_init(track_vars_array);
+               track_vars_array = zend_try_array_init(track_vars_array);
+               if (!track_vars_array) {
+                       return;
+               }
        }
 
        encstr = estrndup(encstr, encstr_len);

diff --git a/ext/mbstring/php_mbregex.c b/ext/mbstring/php_mbregex.c
index cc96e04f39f618682817b5578a54c27b39633d5b..d443999f74364c3d606df9fe4f476817a4b4b0af 100644 (file)
--- a/ext/mbstring/php_mbregex.c
+++ b/ext/mbstring/php_mbregex.c
@@ -863,13 +863,15 @@ static void _php_mb_regex_ereg_exec(INTERNAL_FUNCTION_PARAMETERS, int icase)
        OnigOptionType options;
        char *str;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "zs|z/", &arg_pattern, &string, &string_len, &array) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "zs|z", &arg_pattern, &string, &string_len, &array) == FAILURE) {
                RETURN_FALSE;
        }
 
        if (array != NULL) {
-               zval_ptr_dtor(array);
-               array_init(array);
+               array = zend_try_array_init(array);
+               if (!array) {
+                       return;
+               }
        }
 
        if (!php_mb_check_encoding(

diff --git a/ext/mysqli/mysqli.c b/ext/mysqli/mysqli.c
index f3d5e823099b64b85706ad2e8853034cf88972df..b33ee41336ad8dc54915d052e39327c035a31f15 100644 (file)
--- a/ext/mysqli/mysqli.c
+++ b/ext/mysqli/mysqli.c
@@ -333,7 +333,7 @@ zval *mysqli_read_property(zval *object, zval *member, int type, void **cache_sl
 /* }}} */
 
 /* {{{ mysqli_write_property */
-void mysqli_write_property(zval *object, zval *member, zval *value, void **cache_slot)
+zval *mysqli_write_property(zval *object, zval *member, zval *value, void **cache_slot)
 {
        zval tmp_member;
        mysqli_object *obj;
@@ -353,12 +353,14 @@ void mysqli_write_property(zval *object, zval *member, zval *value, void **cache
        if (hnd) {
                hnd->write_func(obj, value);
        } else {
-               zend_std_write_property(object, member, value, cache_slot);
+               value = zend_std_write_property(object, member, value, cache_slot);
        }
 
        if (member == &tmp_member) {
                zval_ptr_dtor_str(&tmp_member);
        }
+
+       return value;
 }
 /* }}} */
 

diff --git a/ext/mysqli/mysqli_api.c b/ext/mysqli/mysqli_api.c
index 40c7d2982d37463166e4b8a81154c3c411c0e908..e805da9fa798fbcfe40a73fcf5114e7d179fcb50 100644 (file)
--- a/ext/mysqli/mysqli_api.c
+++ b/ext/mysqli/mysqli_api.c
@@ -967,17 +967,11 @@ void mysqli_stmt_fetch_libmysql(INTERNAL_FUNCTION_PARAMETERS)
                        zval *result;
                        /* it must be a reference, isn't it? */
                        if (Z_ISREF(stmt->result.vars[i])) {
-                               result = Z_REFVAL(stmt->result.vars[i]);
+                               result = stmt->result.vars[i];
                        } else {
-                               result = &stmt->result.vars[i];
+                               continue; // but be safe ...
                        }
-                       /*
-                         QQ: Isn't it quite better to call zval_dtor(). What if the user has
-                         assigned a resource, or an array to the bound variable? We are going
-                         to leak probably. zval_dtor() will handle also Unicode/Non-unicode mode.
-                       */
                        /* Even if the string is of length zero there is one byte alloced so efree() in all cases */
-                       zval_ptr_dtor(result);
                        if (!stmt->result.is_null[i]) {
                                switch (stmt->result.buf[i].type) {
                                        case IS_LONG:
@@ -998,16 +992,16 @@ void mysqli_stmt_fetch_libmysql(INTERNAL_FUNCTION_PARAMETERS)
                                                                } while (--j > 0);
                                                                tmp[10]= '\0';
                                                                /* unsigned int > INT_MAX is 10 digits - ALWAYS */
-                                                               ZVAL_STRINGL(result, tmp, 10);
+                                                               ZEND_TRY_ASSIGN_STRINGL(result, tmp, 10);
                                                                efree(tmp);
                                                                break;
                                                        }
 #endif
                                                }
                                                if (stmt->stmt->fields[i].flags & UNSIGNED_FLAG) {
-                                                       ZVAL_LONG(result, *(unsigned int *)stmt->result.buf[i].val);
+                                                       ZEND_TRY_ASSIGN_LONG(result, *(unsigned int *)stmt->result.buf[i].val);
                                                } else {
-                                                       ZVAL_LONG(result, *(int *)stmt->result.buf[i].val);
+                                                       ZEND_TRY_ASSIGN_LONG(result, *(int *)stmt->result.buf[i].val);
                                                }
                                                break;
                                        case IS_DOUBLE:
@@ -1024,7 +1018,7 @@ void mysqli_stmt_fetch_libmysql(INTERNAL_FUNCTION_PARAMETERS)
                                                        dval = *((double *)stmt->result.buf[i].val);
                                                }
 
-                                               ZVAL_DOUBLE(result, dval);
+                                               ZEND_TRY_ASSIGN_DOUBLE(result, dval);
                                                break;
                                        }
                                        case IS_STRING:
@@ -1065,20 +1059,20 @@ void mysqli_stmt_fetch_libmysql(INTERNAL_FUNCTION_PARAMETERS)
                                                                 * use MYSQLI_LL_SPEC.
                                                                 */
                                                                snprintf(tmp, sizeof(tmp), (stmt->stmt->fields[i].flags & UNSIGNED_FLAG)? MYSQLI_LLU_SPEC : MYSQLI_LL_SPEC, llval);
-                                                               ZVAL_STRING(result, tmp);
+                                                               ZEND_TRY_ASSIGN_STRING(result, tmp);
                                                        } else {
-                                                               ZVAL_LONG(result, llval);
+                                                               ZEND_TRY_ASSIGN_LONG(result, llval);
                                                        }
                                                } else {
 #if defined(MYSQL_DATA_TRUNCATED) && MYSQL_VERSION_ID > 50002
                                                        if (ret == MYSQL_DATA_TRUNCATED && *(stmt->stmt->bind[i].error) != 0) {
                                                                /* result was truncated */
-                                                               ZVAL_STRINGL(result, stmt->result.buf[i].val, stmt->stmt->bind[i].buffer_length);
+                                                               ZEND_TRY_ASSIGN_STRINGL(result, stmt->result.buf[i].val, stmt->stmt->bind[i].buffer_length);
                                                        } else {
 #else
                                                        {
 #endif
-                                                               ZVAL_STRINGL(result, stmt->result.buf[i].val, stmt->result.buf[i].output_len);
+                                                               ZEND_TRY_ASSIGN_STRINGL(result, stmt->result.buf[i].val, stmt->result.buf[i].output_len);
                                                        }
                                                }
                                                break;
@@ -1086,7 +1080,7 @@ void mysqli_stmt_fetch_libmysql(INTERNAL_FUNCTION_PARAMETERS)
                                                break;
                                }
                        } else {
-                               ZVAL_NULL(result);
+                               ZEND_TRY_ASSIGN_NULL(result);
                        }
                }
        } else {

diff --git a/ext/mysqlnd/mysqlnd_ps.c b/ext/mysqlnd/mysqlnd_ps.c
index d8671b9da01a93937019c8c076f8be10cb02d723..703c1f050a818804476f7735cab28ffe228d845b 100644 (file)
--- a/ext/mysqlnd/mysqlnd_ps.c
+++ b/ext/mysqlnd/mysqlnd_ps.c
@@ -761,15 +761,11 @@ mysqlnd_stmt_fetch_row_buffered(MYSQLND_RES * result, void * param, const unsign
                                }
 
                                for (i = 0; i < result->field_count; i++) {
-                                       zval *result = &stmt->result_bind[i].zv;
-
-                                       ZVAL_DEREF(result);
-                                       /* Clean what we copied last time */
-                                       zval_ptr_dtor(result);
                                        /* copy the type */
+                                       zval *resultzv = &stmt->result_bind[i].zv;
                                        if (stmt->result_bind[i].bound == TRUE) {
                                                DBG_INF_FMT("i=%u type=%u", i, Z_TYPE(current_row[i]));
-                                               ZVAL_COPY(result, &current_row[i]);
+                                               ZEND_TRY_ASSIGN_COPY_EX(resultzv, &current_row[i], 0);
                                        }
                                }
                        }
@@ -849,17 +845,15 @@ mysqlnd_stmt_fetch_row_unbuffered(MYSQLND_RES * result, void * param, const unsi
                        }
 
                        for (i = 0; i < field_count; i++) {
+                               zval *resultzv = &stmt->result_bind[i].zv;
                                if (stmt->result_bind[i].bound == TRUE) {
                                        zval *data = &result->unbuf->last_row_data[i];
-                                       zval *result = &stmt->result_bind[i].zv;
 
                                        if (Z_TYPE_P(data) == IS_STRING && (meta->fields[i].max_length < (zend_ulong) Z_STRLEN_P(data))){
                                                meta->fields[i].max_length = Z_STRLEN_P(data);
                                        }
 
-                                       ZVAL_DEREF(result);
-                                       zval_ptr_dtor(result);
-                                       ZVAL_COPY_VALUE(result, data);
+                                       ZEND_TRY_ASSIGN_VALUE_EX(resultzv, data, 0);
                                        /* copied data, thus also the ownership. Thus null data */
                                        ZVAL_NULL(data);
                                }
@@ -1025,12 +1019,10 @@ mysqlnd_fetch_stmt_row_cursor(MYSQLND_RES * result, void * param, const unsigned
 
                        /* If no result bind, do nothing. We consumed the data */
                        for (i = 0; i < field_count; i++) {
+                               zval *resultzv = &stmt->result_bind[i].zv;
                                if (stmt->result_bind[i].bound == TRUE) {
                                        zval *data = &result->unbuf->last_row_data[i];
-                                       zval *result = &stmt->result_bind[i].zv;
 
-                                       ZVAL_DEREF(result);
-                                       zval_ptr_dtor(result);
                                        DBG_INF_FMT("i=%u bound_var=%p type=%u refc=%u", i, &stmt->result_bind[i].zv,
                                                                Z_TYPE_P(data), Z_REFCOUNTED(stmt->result_bind[i].zv)?
                                                                Z_REFCOUNT(stmt->result_bind[i].zv) : 0);
@@ -1040,7 +1032,7 @@ mysqlnd_fetch_stmt_row_cursor(MYSQLND_RES * result, void * param, const unsigned
                                                meta->fields[i].max_length = Z_STRLEN_P(data);
                                        }
 
-                                       ZVAL_COPY_VALUE(result, data);
+                                       ZEND_TRY_ASSIGN_VALUE_EX(resultzv, data, 0);
                                        /* copied data, thus also the ownership. Thus null data */
                                        ZVAL_NULL(data);
                                }
@@ -1120,28 +1112,6 @@ MYSQLND_METHOD(mysqlnd_stmt, fetch)(MYSQLND_STMT * const s, zend_bool * const fe
        SET_EMPTY_ERROR(stmt->error_info);
        SET_EMPTY_ERROR(conn->error_info);
 
-       DBG_INF_FMT("result_bind=%p separated_once=%u", &stmt->result_bind, stmt->result_zvals_separated_once);
-       /*
-         The user might have not bound any variables for result.
-         Do the binding once she does it.
-       */
-       if (stmt->result_bind && !stmt->result_zvals_separated_once) {
-               unsigned int i;
-               /*
-                 mysqlnd_stmt_store_result() has been called free the bind
-                 variables to prevent leaking of their previous content.
-               */
-               for (i = 0; i < stmt->result->field_count; i++) {
-                       if (stmt->result_bind[i].bound == TRUE) {
-                               zval *result = &stmt->result_bind[i].zv;
-                               ZVAL_DEREF(result);
-                               zval_ptr_dtor(result);
-                               ZVAL_NULL(result);
-                       }
-               }
-               stmt->result_zvals_separated_once = TRUE;
-       }
-
        ret = stmt->result->m.fetch_row(stmt->result, (void*)s, 0, fetched_anything);
        DBG_RETURN(ret);
 }
@@ -1537,7 +1507,6 @@ MYSQLND_METHOD(mysqlnd_stmt, bind_result)(MYSQLND_STMT * const s,
                }
 
                mysqlnd_stmt_separate_result_bind(s);
-               stmt->result_zvals_separated_once = FALSE;
                stmt->result_bind = result_bind;
                for (i = 0; i < stmt->field_count; i++) {
                        /* Prevent from freeing */

diff --git a/ext/mysqlnd/mysqlnd_structs.h b/ext/mysqlnd/mysqlnd_structs.h
index 8a9018356e75f958293d0e6b5605bbb0b5c994e4..a5c1359853193b9c906736610c3b16d449ddca69 100644 (file)
--- a/ext/mysqlnd/mysqlnd_structs.h
+++ b/ext/mysqlnd/mysqlnd_structs.h
@@ -1309,7 +1309,6 @@ struct st_mysqlnd_stmt_data
        unsigned char                           send_types_to_server;
        MYSQLND_PARAM_BIND                      *param_bind;
        MYSQLND_RESULT_BIND                     *result_bind;
-       zend_bool                                       result_zvals_separated_once;
 
        MYSQLND_UPSERT_STATUS *         upsert_status;
        MYSQLND_UPSERT_STATUS           upsert_status_impl;

diff --git a/ext/oci8/oci8_interface.c b/ext/oci8/oci8_interface.c
index 2e05afa5277fce3115854a9292818b83fdfdb48e..8eda816bd5e09f841856bc1958f358e2fa0e9bee 100644 (file)
--- a/ext/oci8/oci8_interface.c
+++ b/ext/oci8/oci8_interface.c
@@ -1473,7 +1473,7 @@ PHP_FUNCTION(oci_fetch_all)
 
        ZEND_PARSE_PARAMETERS_START(2, 5)
                Z_PARAM_RESOURCE(z_statement)
-               Z_PARAM_ZVAL_DEREF_EX(array, 0, 1)
+               Z_PARAM_ZVAL(array)
                Z_PARAM_OPTIONAL
                Z_PARAM_LONG(skip)
                Z_PARAM_LONG(maxrows)
@@ -1482,20 +1482,21 @@ PHP_FUNCTION(oci_fetch_all)
 
        PHP_OCI_ZVAL_TO_STATEMENT(z_statement, statement);
 
-       zval_ptr_dtor(array);
-
        while (skip--) {
                if (php_oci_statement_fetch(statement, nrows)) {
-                       array_init(array);
+                       zend_try_array_init(array);
                        RETURN_LONG(0);
                }
        }
 
        if (flags & PHP_OCI_FETCHSTATEMENT_BY_ROW) {
                /* Fetch by Row: array will contain one sub-array per query row */
-               array_init(array);
-               columns = safe_emalloc(statement->ncolumns, sizeof(php_oci_out_column *), 0);
+               array = zend_try_array_init(array);
+               if (!array) {
+                       return;
+               }
 
+               columns = safe_emalloc(statement->ncolumns, sizeof(php_oci_out_column *), 0);
                for (i = 0; i < statement->ncolumns; i++) {
                        columns[ i ] = php_oci_statement_get_column(statement, i + 1, NULL, 0);
                }
@@ -1534,7 +1535,11 @@ PHP_FUNCTION(oci_fetch_all)
 
        } else { /* default to BY_COLUMN */
                /* Fetch by columns: array will contain one sub-array per query column */
-               array_init_size(array, statement->ncolumns);
+               array = zend_try_array_init_size(array, statement->ncolumns);
+               if (!array) {
+                       return;
+               }
+
                columns = safe_emalloc(statement->ncolumns, sizeof(php_oci_out_column *), 0);
                outarrs = safe_emalloc(statement->ncolumns, sizeof(zval*), 0);
 

diff --git a/ext/odbc/php_odbc.c b/ext/odbc/php_odbc.c
index b7b67562a4941533c542f760275f38b78785dc5d..9156347e830edc2c059d0d0cc6e417febaf0eb14 100644 (file)
--- a/ext/odbc/php_odbc.c
+++ b/ext/odbc/php_odbc.c
@@ -1876,13 +1876,13 @@ PHP_FUNCTION(odbc_fetch_into)
 #endif /* HAVE_SQL_EXTENDED_FETCH */
 
 #ifdef HAVE_SQL_EXTENDED_FETCH
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rz/|l", &pv_res, &pv_res_arr, &pv_row) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rz|l", &pv_res, &pv_res_arr, &pv_row) == FAILURE) {
                return;
        }
 
        rownum = pv_row;
 #else
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rz/", &pv_res, &pv_res_arr) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rz", &pv_res, &pv_res_arr) == FAILURE) {
                return;
        }
 #endif /* HAVE_SQL_EXTENDED_FETCH */
@@ -1896,8 +1896,9 @@ PHP_FUNCTION(odbc_fetch_into)
                RETURN_FALSE;
        }
 
-       if (Z_TYPE_P(pv_res_arr) != IS_ARRAY) {
-               array_init(pv_res_arr);
+       pv_res_arr = zend_try_array_init(pv_res_arr);
+       if (!pv_res_arr) {
+               return;
        }
 
 #ifdef HAVE_SQL_EXTENDED_FETCH

diff --git a/ext/opcache/Optimizer/compact_literals.c b/ext/opcache/Optimizer/compact_literals.c
index 9e3a0ab9a185a86d45f9fb9e1643e4f56398337e..397458365f964c3a21732018683ecb12fec18205 100644 (file)
--- a/ext/opcache/Optimizer/compact_literals.c
+++ b/ext/opcache/Optimizer/compact_literals.c
@@ -108,7 +108,7 @@ static uint32_t add_static_slot(HashTable     *hash,
                ret = Z_LVAL_P(pos);
        } else {
                ret = *cache_size;
-               *cache_size += 2 * sizeof(void *);
+               *cache_size += (kind == LITERAL_STATIC_PROPERTY ? 3 : 2) * sizeof(void *);
                ZVAL_LONG(&tmp, ret);
                zend_hash_add(hash, key, &tmp);
        }
@@ -183,6 +183,8 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
                                        }
                                        LITERAL_INFO(opline->op2.constant, LITERAL_CLASS_CONST, 1);
                                        break;
+                               case ZEND_ASSIGN_STATIC_PROP:
+                               case ZEND_ASSIGN_STATIC_PROP_REF:
                                case ZEND_FETCH_STATIC_PROP_R:
                                case ZEND_FETCH_STATIC_PROP_W:
                                case ZEND_FETCH_STATIC_PROP_RW:
@@ -191,6 +193,11 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
                                case ZEND_FETCH_STATIC_PROP_FUNC_ARG:
                                case ZEND_UNSET_STATIC_PROP:
                                case ZEND_ISSET_ISEMPTY_STATIC_PROP:
+                               case ZEND_PRE_INC_STATIC_PROP:
+                               case ZEND_PRE_DEC_STATIC_PROP:
+                               case ZEND_POST_INC_STATIC_PROP:
+                               case ZEND_POST_DEC_STATIC_PROP:
+literals_handle_static_prop:
                                        if (opline->op2_type == IS_CONST) {
                                                LITERAL_INFO(opline->op2.constant, LITERAL_CLASS, 2);
                                        }
@@ -210,6 +217,7 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
                                        }
                                        break;
                                case ZEND_ASSIGN_OBJ:
+                               case ZEND_ASSIGN_OBJ_REF:
                                case ZEND_FETCH_OBJ_R:
                                case ZEND_FETCH_OBJ_W:
                                case ZEND_FETCH_OBJ_RW:
@@ -238,6 +246,9 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
                                case ZEND_ASSIGN_BW_OR:
                                case ZEND_ASSIGN_BW_AND:
                                case ZEND_ASSIGN_BW_XOR:
+                                       if (opline->extended_value == ZEND_ASSIGN_STATIC_PROP) {
+                                               goto literals_handle_static_prop;
+                                       }
                                        if (opline->op2_type == IS_CONST) {
                                                if (opline->extended_value == ZEND_ASSIGN_OBJ) {
                                                        LITERAL_INFO(opline->op2.constant, LITERAL_PROPERTY, 1);
@@ -547,24 +558,48 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
                                case ZEND_ASSIGN_BW_OR:
                                case ZEND_ASSIGN_BW_AND:
                                case ZEND_ASSIGN_BW_XOR:
-                                       if (opline->extended_value != ZEND_ASSIGN_OBJ) {
-                                               break;
+                                       if (opline->extended_value == ZEND_ASSIGN_STATIC_PROP) {
+                                               if (opline->op1_type == IS_CONST) {
+                                                       // op1 static property
+                                                       if (opline->op2_type == IS_CONST) {
+                                                               (opline+1)->extended_value = add_static_slot(&hash, op_array,
+                                                                       opline->op2.constant,
+                                                                       opline->op1.constant,
+                                                                       LITERAL_STATIC_PROPERTY,
+                                                                       &cache_size);
+                                                       } else {
+                                                               (opline+1)->extended_value = cache_size;
+                                                               cache_size += 3 * sizeof(void *);
+                                                       }
+                                               } else if (opline->op2_type == IS_CONST) {
+                                                       // op2 class
+                                                       if (class_slot[opline->op2.constant] >= 0) {
+                                                               (opline+1)->extended_value = class_slot[opline->op2.constant];
+                                                       } else {
+                                                               (opline+1)->extended_value = cache_size;
+                                                               class_slot[opline->op2.constant] = cache_size;
+                                                               cache_size += sizeof(void *);
+                                                       }
+                                               }
                                        }
-                                       if (opline->op2_type == IS_CONST) {
-                                               // op2 property
-                                               if (opline->op1_type == IS_UNUSED &&
-                                                   property_slot[opline->op2.constant] >= 0) {
-                                                       (opline+1)->extended_value = property_slot[opline->op2.constant];
-                                               } else {
-                                                       (opline+1)->extended_value = cache_size;
-                                                       cache_size += 2 * sizeof(void *);
-                                                       if (opline->op1_type == IS_UNUSED) {
-                                                               property_slot[opline->op2.constant] = (opline+1)->extended_value;
+                                       if (opline->extended_value == ZEND_ASSIGN_OBJ) {
+                                               if (opline->op2_type == IS_CONST) {
+                                                       // op2 property
+                                                       if (opline->op1_type == IS_UNUSED &&
+                                                           property_slot[opline->op2.constant] >= 0) {
+                                                               (opline+1)->extended_value = property_slot[opline->op2.constant];
+                                                       } else {
+                                                               (opline+1)->extended_value = cache_size;
+                                                               cache_size += 3 * sizeof(void *);
+                                                               if (opline->op1_type == IS_UNUSED) {
+                                                                       property_slot[opline->op2.constant] = (opline+1)->extended_value;
+                                                               }
                                                        }
                                                }
                                        }
                                        break;
                                case ZEND_ASSIGN_OBJ:
+                               case ZEND_ASSIGN_OBJ_REF:
                                case ZEND_FETCH_OBJ_R:
                                case ZEND_FETCH_OBJ_W:
                                case ZEND_FETCH_OBJ_RW:
@@ -580,12 +615,12 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
                                                // op2 property
                                                if (opline->op1_type == IS_UNUSED &&
                                                    property_slot[opline->op2.constant] >= 0) {
-                                                       opline->extended_value = property_slot[opline->op2.constant];
+                                                       opline->extended_value = property_slot[opline->op2.constant] | (opline->extended_value & ZEND_FETCH_OBJ_FLAGS);
                                                } else {
-                                                       opline->extended_value = cache_size;
-                                                       cache_size += 2 * sizeof(void *);
+                                                       opline->extended_value = cache_size | (opline->extended_value & ZEND_FETCH_OBJ_FLAGS);
+                                                       cache_size += 3 * sizeof(void *);
                                                        if (opline->op1_type == IS_UNUSED) {
-                                                               property_slot[opline->op2.constant] = opline->extended_value;
+                                                               property_slot[opline->op2.constant] = opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS;
                                                        }
                                                }
                                        }
@@ -598,7 +633,7 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
                                                        opline->extended_value = property_slot[opline->op2.constant] | (opline->extended_value & ZEND_ISEMPTY);
                                                } else {
                                                        opline->extended_value = cache_size | (opline->extended_value & ZEND_ISEMPTY);
-                                                       cache_size += 2 * sizeof(void *);
+                                                       cache_size += 3 * sizeof(void *);
                                                        if (opline->op1_type == IS_UNUSED) {
                                                                property_slot[opline->op2.constant] = opline->extended_value & ~ZEND_ISEMPTY;
                                                        }
@@ -689,6 +724,8 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
                                                cache_size += 2 * sizeof(void *);
                                        }
                                        break;
+                               case ZEND_ASSIGN_STATIC_PROP:
+                               case ZEND_ASSIGN_STATIC_PROP_REF:
                                case ZEND_FETCH_STATIC_PROP_R:
                                case ZEND_FETCH_STATIC_PROP_W:
                                case ZEND_FETCH_STATIC_PROP_RW:
@@ -696,30 +733,11 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
                                case ZEND_FETCH_STATIC_PROP_UNSET:
                                case ZEND_FETCH_STATIC_PROP_FUNC_ARG:
                                case ZEND_UNSET_STATIC_PROP:
-                                       if (opline->op1_type == IS_CONST) {
-                                               // op1 static property
-                                               if (opline->op2_type == IS_CONST) {
-                                                       opline->extended_value = add_static_slot(&hash, op_array,
-                                                               opline->op2.constant,
-                                                               opline->op1.constant,
-                                                               LITERAL_STATIC_PROPERTY,
-                                                               &cache_size);
-                                               } else {
-                                                       opline->extended_value = cache_size;
-                                                       cache_size += 2 * sizeof(void *);
-                                               }
-                                       } else if (opline->op2_type == IS_CONST) {
-                                               // op2 class
-                                               if (class_slot[opline->op2.constant] >= 0) {
-                                                       opline->extended_value = class_slot[opline->op2.constant];
-                                               } else {
-                                                       opline->extended_value = cache_size;
-                                                       cache_size += sizeof(void *);
-                                                       class_slot[opline->op2.constant] = opline->extended_value;
-                                               }
-                                       }
-                                       break;
                                case ZEND_ISSET_ISEMPTY_STATIC_PROP:
+                               case ZEND_PRE_INC_STATIC_PROP:
+                               case ZEND_PRE_DEC_STATIC_PROP:
+                               case ZEND_POST_INC_STATIC_PROP:
+                               case ZEND_POST_DEC_STATIC_PROP:
                                        if (opline->op1_type == IS_CONST) {
                                                // op1 static property
                                                if (opline->op2_type == IS_CONST) {
@@ -727,19 +745,19 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
                                                                opline->op2.constant,
                                                                opline->op1.constant,
                                                                LITERAL_STATIC_PROPERTY,
-                                                               &cache_size) | (opline->extended_value & ZEND_ISEMPTY);
+                                                               &cache_size) | (opline->extended_value & ZEND_FETCH_OBJ_FLAGS);
                                                } else {
-                                                       opline->extended_value = cache_size | (opline->extended_value & ZEND_ISEMPTY);
-                                                       cache_size += 2 * sizeof(void *);
+                                                       opline->extended_value = cache_size | (opline->extended_value & ZEND_FETCH_OBJ_FLAGS);
+                                                       cache_size += 3 * sizeof(void *);
                                                }
                                        } else if (opline->op2_type == IS_CONST) {
                                                // op2 class
                                                if (class_slot[opline->op2.constant] >= 0) {
-                                                       opline->extended_value = class_slot[opline->op2.constant] | (opline->extended_value & ZEND_ISEMPTY);
+                                                       opline->extended_value = class_slot[opline->op2.constant] | (opline->extended_value & ZEND_FETCH_OBJ_FLAGS);
                                                } else {
-                                                       opline->extended_value = cache_size | (opline->extended_value & ZEND_ISEMPTY);
+                                                       opline->extended_value = cache_size | (opline->extended_value & ZEND_FETCH_OBJ_FLAGS);
+                                                       class_slot[opline->op2.constant] = cache_size;
                                                        cache_size += sizeof(void *);
-                                                       class_slot[opline->op2.constant] = opline->extended_value & ~ZEND_ISEMPTY;
                                                }
                                        }
                                        break;

diff --git a/ext/opcache/Optimizer/dce.c b/ext/opcache/Optimizer/dce.c
index 89898393a7af0d1f48eadec0fc4bfb8e83b56c97..95755d559ffb23ed17c284ae22fc15624dacb44a 100644 (file)
--- a/ext/opcache/Optimizer/dce.c
+++ b/ext/opcache/Optimizer/dce.c
@@ -330,6 +330,9 @@ static zend_bool try_remove_var_def(context *ctx, int free_var, int use_chain, z
                                case ZEND_ASSIGN_REF:
                                case ZEND_ASSIGN_DIM:
                                case ZEND_ASSIGN_OBJ:
+                               case ZEND_ASSIGN_OBJ_REF:
+                               case ZEND_ASSIGN_STATIC_PROP:
+                               case ZEND_ASSIGN_STATIC_PROP_REF:
                                case ZEND_ASSIGN_ADD:
                                case ZEND_ASSIGN_SUB:
                                case ZEND_ASSIGN_MUL:

diff --git a/ext/opcache/Optimizer/escape_analysis.c b/ext/opcache/Optimizer/escape_analysis.c
index f88de6202a5db5a95ea34bde86bac61ffa229ea3..a92d773783ec04b5149cf9a41e856b8b11cff1b9 100644 (file)
--- a/ext/opcache/Optimizer/escape_analysis.c
+++ b/ext/opcache/Optimizer/escape_analysis.c
@@ -217,6 +217,7 @@ static int is_allocation_def(zend_op_array *op_array, zend_ssa *ssa, int def, in
                                break;
                        case ZEND_ASSIGN_DIM:
                        case ZEND_ASSIGN_OBJ:
+                       case ZEND_ASSIGN_OBJ_REF:
                                if (OP1_INFO() & (MAY_BE_UNDEF | MAY_BE_NULL | MAY_BE_FALSE)) {
                                        /* implicit object/array allocation */
                                        return 1;
@@ -259,6 +260,7 @@ static int is_local_def(zend_op_array *op_array, zend_ssa *ssa, int def, int var
                                return 1;
                        case ZEND_ASSIGN_DIM:
                        case ZEND_ASSIGN_OBJ:
+                       case ZEND_ASSIGN_OBJ_REF:
                                return 1;
                        case ZEND_ASSIGN_ADD:
                        case ZEND_ASSIGN_SUB:
@@ -328,6 +330,7 @@ static int is_escape_use(zend_op_array *op_array, zend_ssa *ssa, int use, int va
                                /* break missing intentionally */
                        case ZEND_ASSIGN_DIM:
                        case ZEND_ASSIGN_OBJ:
+                       case ZEND_ASSIGN_OBJ_REF:
                                break;
                        case ZEND_PRE_INC_OBJ:
                        case ZEND_PRE_DEC_OBJ:
@@ -508,7 +511,8 @@ int zend_ssa_escape_analysis(const zend_script *script, zend_op_array *op_array,
 
                                                        if (opline->opcode == ZEND_OP_DATA &&
                                                            ((opline-1)->opcode == ZEND_ASSIGN_DIM ||
-                                                            (opline-1)->opcode == ZEND_ASSIGN_OBJ) &&
+                                                            (opline-1)->opcode == ZEND_ASSIGN_OBJ ||
+                                                            (opline-1)->opcode == ZEND_ASSIGN_OBJ_REF) &&
                                                            op->op1_use == i &&
                                                            (op-1)->op1_use >= 0) {
                                                                enclosing_root = ees[(op-1)->op1_use];

diff --git a/ext/opcache/Optimizer/sccp.c b/ext/opcache/Optimizer/sccp.c
index 08e1584923a9c4e5846517d55a2e9a30e62d588a..69a3e81c6b6686722ca2b738ecfc379aeb8f66db 100644 (file)
--- a/ext/opcache/Optimizer/sccp.c
+++ b/ext/opcache/Optimizer/sccp.c
@@ -203,6 +203,7 @@ static zend_bool can_replace_op1(
                case ZEND_ASSIGN_REF:
                case ZEND_ASSIGN_DIM:
                case ZEND_ASSIGN_OBJ:
+               case ZEND_ASSIGN_OBJ_REF:
                case ZEND_ASSIGN_ADD:
                case ZEND_ASSIGN_SUB:
                case ZEND_ASSIGN_MUL:
@@ -251,6 +252,9 @@ static zend_bool can_replace_op1(
                case ZEND_VERIFY_RETURN_TYPE:
                        // TODO: This would require a non-local change ???
                        return 0;
+               case ZEND_OP_DATA:
+                       return (opline - 1)->opcode != ZEND_ASSIGN_OBJ_REF &&
+                               (opline - 1)->opcode != ZEND_ASSIGN_STATIC_PROP_REF;
                default:
                        if (ssa_op->op1_def != -1) {
                                ZEND_ASSERT(0);
@@ -1400,7 +1404,7 @@ static void sccp_visit_instr(scdf_ctx *scdf, zend_op *opline, zend_ssa_op *ssa_o
                        if (op2) {
                                SKIP_IF_TOP(op2);
                        }
-                       if (!opline->extended_value) {
+                       if (opline->extended_value == 0) {
                                if (zend_optimizer_eval_binary_op(&zv, zend_compound_assign_to_binary_op(opline->opcode), op1, op2) == SUCCESS) {
                                        SET_RESULT(op1, &zv);
                                        SET_RESULT(result, &zv);
@@ -1494,6 +1498,11 @@ static void sccp_visit_instr(scdf_ctx *scdf, zend_op *opline, zend_ssa_op *ssa_o
                                                zval_ptr_dtor_nogc(&zv);
                                        }
                                }
+                       } else if (opline->extended_value == ZEND_ASSIGN_STATIC_PROP) {
+                               SET_RESULT_BOT(result);
+                               break;
+                       } else {
+                               ZEND_ASSERT(0 && "Invalid compound assignment kind");
                        }
                        SET_RESULT_BOT(result);
                        SET_RESULT_BOT(op1);

diff --git a/ext/opcache/Optimizer/zend_dfg.c b/ext/opcache/Optimizer/zend_dfg.c
index 4430f193a89f0295eaac589a2d9ca528b70a82d4..66dd15da002d1a2bf7e25997a3777441dbe2bd0f 100644 (file)
--- a/ext/opcache/Optimizer/zend_dfg.c
+++ b/ext/opcache/Optimizer/zend_dfg.c
@@ -52,8 +52,14 @@ int zend_build_dfg(const zend_op_array *op_array, const zend_cfg *cfg, zend_dfg
                                if (next < end && next->opcode == ZEND_OP_DATA) {
                                        if (next->op1_type & (IS_CV|IS_VAR|IS_TMP_VAR)) {
                                                var_num = EX_VAR_TO_NUM(next->op1.var);
-                                               if (!DFG_ISSET(def, set_size, j, var_num)) {
+                                               if (opline->opcode == ZEND_ASSIGN_OBJ_REF
+                                                               || opline->opcode == ZEND_ASSIGN_STATIC_PROP_REF) {
                                                        DFG_SET(use, set_size, j, var_num);
+                                                       DFG_SET(def, set_size, j, var_num);
+                                               } else {
+                                                       if (!DFG_ISSET(def, set_size, j, var_num)) {
+                                                               DFG_SET(use, set_size, j, var_num);
+                                                       }
                                                }
                                        }
                                        if (next->op2_type & (IS_CV|IS_VAR|IS_TMP_VAR)) {
@@ -92,6 +98,7 @@ int zend_build_dfg(const zend_op_array *op_array, const zend_cfg *cfg, zend_dfg
                                        case ZEND_UNSET_CV:
                                        case ZEND_ASSIGN:
                                        case ZEND_ASSIGN_REF:
+                                       case ZEND_ASSIGN_OBJ_REF:
                                        case ZEND_BIND_GLOBAL:
                                        case ZEND_BIND_STATIC:
                                        case ZEND_SEND_VAR_EX:

diff --git a/ext/opcache/Optimizer/zend_dump.c b/ext/opcache/Optimizer/zend_dump.c
index 90107785b74a29516df247eb61404ea9b1a33404..d5f6c4564bad0f20d1731b11a446c80e8a958ed8 100644 (file)
--- a/ext/opcache/Optimizer/zend_dump.c
+++ b/ext/opcache/Optimizer/zend_dump.c
@@ -451,6 +451,8 @@ static void zend_dump_op(const zend_op_array *op_array, const zend_basic_block *
                        fprintf(stderr, " (dim)");
                } else if (opline->extended_value == ZEND_ASSIGN_OBJ) {
                        fprintf(stderr, " (obj)");
+               } else if (opline->extended_value == ZEND_ASSIGN_STATIC_PROP) {
+                       fprintf(stderr, " (static prop)");
                }
        } else if (ZEND_VM_EXT_TYPE == (flags & ZEND_VM_EXT_MASK)) {
                switch (opline->extended_value) {
@@ -554,7 +556,7 @@ static void zend_dump_op(const zend_op_array *op_array, const zend_basic_block *
        } else if (ZEND_VM_EXT_SRC == (flags & ZEND_VM_EXT_MASK)) {
                if (opline->extended_value == ZEND_RETURNS_VALUE) {
                        fprintf(stderr, " (value)");
-               } else if (opline->extended_value == ZEND_RETURNS_FUNCTION) {
+               } else if (opline->extended_value & ZEND_RETURNS_FUNCTION) {
                        fprintf(stderr, " (function)");
                }
        } else {
@@ -585,6 +587,16 @@ static void zend_dump_op(const zend_op_array *op_array, const zend_basic_block *
                                fprintf(stderr, " (ref)");
                        }
                }
+               if ((ZEND_VM_EXT_DIM_OBJ_WRITE|ZEND_VM_EXT_FETCH_REF) & flags) {
+                       uint32_t obj_flags = opline->extended_value & ZEND_FETCH_OBJ_FLAGS;
+                       if (obj_flags == ZEND_FETCH_REF) {
+                               fprintf(stderr, " (ref)");
+                       } else if (obj_flags == ZEND_FETCH_DIM_WRITE) {
+                               fprintf(stderr, " (dim write)");
+                       } else if (obj_flags == ZEND_FETCH_OBJ_WRITE) {
+                               fprintf(stderr, " (obj write)");
+                       }
+               }
        }
 
        if (opline->op1_type == IS_CONST) {

diff --git a/ext/opcache/Optimizer/zend_inference.c b/ext/opcache/Optimizer/zend_inference.c
index 9f1dfdba201f52ef3c5a597ccdfea7e2d9bb9216..980f3c5fea27f33858dc54c033eebde72a77bc80 100644 (file)
--- a/ext/opcache/Optimizer/zend_inference.c
+++ b/ext/opcache/Optimizer/zend_inference.c
@@ -2240,6 +2240,24 @@ static inline zend_class_entry *get_class_entry(const zend_script *script, zend_
        return NULL;
 }
 
+static uint32_t zend_convert_type_code_to_may_be(zend_uchar type_code) {
+       switch (type_code) {
+               case IS_VOID:
+                       return MAY_BE_NULL;
+               case IS_CALLABLE:
+                       return MAY_BE_STRING|MAY_BE_OBJECT|MAY_BE_ARRAY|MAY_BE_ARRAY_KEY_ANY|MAY_BE_ARRAY_OF_ANY|MAY_BE_ARRAY_OF_REF;
+               case IS_ITERABLE:
+                       return MAY_BE_OBJECT|MAY_BE_ARRAY|MAY_BE_ARRAY_KEY_ANY|MAY_BE_ARRAY_OF_ANY|MAY_BE_ARRAY_OF_REF;
+               case IS_ARRAY:
+                       return MAY_BE_ARRAY|MAY_BE_ARRAY_KEY_ANY|MAY_BE_ARRAY_OF_ANY|MAY_BE_ARRAY_OF_REF;
+               case _IS_BOOL:
+                       return MAY_BE_TRUE|MAY_BE_FALSE;
+               default:
+                       ZEND_ASSERT(type_code < IS_REFERENCE);
+                       return 1 << type_code;
+       }
+}
+
 static uint32_t zend_fetch_arg_info(const zend_script *script, zend_arg_info *arg_info, zend_class_entry **pce)
 {
        uint32_t tmp = 0;
@@ -2252,22 +2270,7 @@ static uint32_t zend_fetch_arg_info(const zend_script *script, zend_arg_info *ar
                *pce = get_class_entry(script, lcname);
                zend_string_release_ex(lcname, 0);
        } else if (ZEND_TYPE_IS_CODE(arg_info->type)) {
-               zend_uchar type_hint = ZEND_TYPE_CODE(arg_info->type);
-
-               if (type_hint == IS_VOID) {
-                       tmp |= MAY_BE_NULL;
-               } else if (type_hint == IS_CALLABLE) {
-                       tmp |= MAY_BE_STRING|MAY_BE_OBJECT|MAY_BE_ARRAY|MAY_BE_ARRAY_KEY_ANY|MAY_BE_ARRAY_OF_ANY|MAY_BE_ARRAY_OF_REF;
-               } else if (type_hint == IS_ITERABLE) {
-                       tmp |= MAY_BE_OBJECT|MAY_BE_ARRAY|MAY_BE_ARRAY_KEY_ANY|MAY_BE_ARRAY_OF_ANY|MAY_BE_ARRAY_OF_REF;
-               } else if (type_hint == IS_ARRAY) {
-                       tmp |= MAY_BE_ARRAY|MAY_BE_ARRAY_KEY_ANY|MAY_BE_ARRAY_OF_ANY|MAY_BE_ARRAY_OF_REF;
-               } else if (type_hint == _IS_BOOL) {
-                       tmp |= MAY_BE_TRUE|MAY_BE_FALSE;
-               } else {
-                       ZEND_ASSERT(type_hint < IS_REFERENCE);
-                       tmp |= 1 << type_hint;
-               }
+               tmp |= zend_convert_type_code_to_may_be(ZEND_TYPE_CODE(arg_info->type));
        } else {
                tmp |= MAY_BE_ANY|MAY_BE_ARRAY_KEY_ANY|MAY_BE_ARRAY_OF_ANY|MAY_BE_ARRAY_OF_REF;
        }
@@ -2277,6 +2280,123 @@ static uint32_t zend_fetch_arg_info(const zend_script *script, zend_arg_info *ar
        return tmp;
 }
 
+static zend_property_info *lookup_prop_info(zend_class_entry *ce, zend_string *name, zend_class_entry *scope) {
+       zend_property_info *prop_info;
+
+       /* If the class is linked, reuse the precise runtime logic. */
+       if (ce->ce_flags & ZEND_ACC_LINKED) {
+               zend_class_entry *prev_scope = EG(fake_scope);
+               EG(fake_scope) = scope;
+               prop_info = zend_get_property_info(ce, name, 1);
+               EG(fake_scope) = prev_scope;
+               if (prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO) {
+                       return prop_info;
+               }
+               return NULL;
+       }
+
+       /* Otherwise, handle only some safe cases */
+       prop_info = zend_hash_find_ptr(&ce->properties_info, name);
+       if (prop_info &&
+               ((prop_info->ce == scope) ||
+                (!scope && (prop_info->flags & ZEND_ACC_PUBLIC)))
+       ) {
+               return prop_info;
+       }
+       return NULL;
+}
+
+static zend_property_info *zend_fetch_prop_info(const zend_op_array *op_array, zend_ssa *ssa, zend_op *opline, int i)
+{
+       zend_property_info *prop_info = NULL;
+       if (opline->op2_type == IS_CONST) {
+               zend_class_entry *ce = NULL;
+
+               if (opline->op1_type == IS_UNUSED) {
+                       ce = op_array->scope;
+               } else if (ssa->ops[i].op1_use >= 0) {
+                       ce = ssa->var_info[ssa->ops[i].op1_use].ce;
+               }
+               if (ce) {
+                       prop_info = lookup_prop_info(ce,
+                               Z_STR_P(CRT_CONSTANT_EX(op_array, opline, opline->op2, ssa->rt_constants)),
+                               op_array->scope);
+                       if (prop_info && (prop_info->flags & ZEND_ACC_STATIC)) {
+                               prop_info = NULL;
+                       }
+               }
+       }
+       return prop_info;
+}
+
+static zend_property_info *zend_fetch_static_prop_info(const zend_script *script, const zend_op_array *op_array, zend_ssa *ssa, zend_op *opline)
+{
+       zend_property_info *prop_info = NULL;
+       if (opline->op1_type == IS_CONST) {
+               zend_class_entry *ce = NULL;
+               if (opline->op2_type == IS_UNUSED) {
+                       int fetch_type = opline->op2.num & ZEND_FETCH_CLASS_MASK;
+                       switch (fetch_type) {
+                               case ZEND_FETCH_CLASS_SELF:
+                               case ZEND_FETCH_CLASS_STATIC:
+                                       /* We enforce that static property types cannot change during inheritance, so
+                                        * handling static the same way as self here is legal. */
+                                       ce = op_array->scope;
+                                       break;
+                               case ZEND_FETCH_CLASS_PARENT:
+                                       if (op_array->scope) {
+                                               ce = op_array->scope->parent;
+                                       }
+                                       break;
+                       }
+               } else if (opline->op2_type == IS_CONST) {
+                       zval *zv = CRT_CONSTANT_EX(op_array, opline, opline->op2, ssa->rt_constants);
+                       ce = get_class_entry(script, Z_STR_P(zv + 1));
+               }
+
+               if (ce) {
+                       zval *zv = CRT_CONSTANT_EX(op_array, opline, opline->op1, ssa->rt_constants);
+                       prop_info = lookup_prop_info(ce, Z_STR_P(zv), op_array->scope);
+                       if (prop_info && !(prop_info->flags & ZEND_ACC_STATIC)) {
+                               prop_info = NULL;
+                       }
+               }
+       }
+       return prop_info;
+}
+
+static uint32_t zend_fetch_prop_type(const zend_script *script, zend_property_info *prop_info, zend_class_entry **pce)
+{
+       if (prop_info && ZEND_TYPE_IS_SET(prop_info->type)) {
+               uint32_t type = ZEND_TYPE_IS_CLASS(prop_info->type)
+                       ? MAY_BE_OBJECT
+                       : zend_convert_type_code_to_may_be(ZEND_TYPE_CODE(prop_info->type));
+
+               if (ZEND_TYPE_ALLOW_NULL(prop_info->type)) {
+                       type |= MAY_BE_NULL;
+               }
+               if (type & (MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_OBJECT|MAY_BE_RESOURCE)) {
+                       type |= MAY_BE_RC1 | MAY_BE_RCN;
+               }
+               if (pce) {
+                       if (ZEND_TYPE_IS_CE(prop_info->type)) {
+                               *pce = ZEND_TYPE_CE(prop_info->type);
+                       } else if (ZEND_TYPE_IS_NAME(prop_info->type)) {
+                               zend_string *lcname = zend_string_tolower(ZEND_TYPE_NAME(prop_info->type));
+                               *pce = get_class_entry(script, lcname);
+                               zend_string_release(lcname);
+                       } else {
+                               *pce = NULL;
+                       }
+               }
+               return type;
+       }
+       if (pce) {
+               *pce = NULL;
+       }
+       return MAY_BE_ANY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_ANY | MAY_BE_ARRAY_OF_REF | MAY_BE_RC1 | MAY_BE_RCN;
+}
+
 static int zend_update_type_info(const zend_op_array *op_array,
                                   zend_ssa            *ssa,
                                   const zend_script   *script,
@@ -2474,13 +2594,14 @@ static int zend_update_type_info(const zend_op_array *op_array,
                case ZEND_ASSIGN_BW_OR:
                case ZEND_ASSIGN_BW_AND:
                case ZEND_ASSIGN_BW_XOR:
-               case ZEND_ASSIGN_CONCAT:
+               case ZEND_ASSIGN_CONCAT: {
+                       zend_property_info *prop_info = NULL;
                        orig = 0;
                        tmp = 0;
                        if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-                       tmp |= MAY_BE_REF;
+                               prop_info = zend_fetch_prop_info(op_array, ssa, opline, i);
                                orig = t1;
-                               t1 = MAY_BE_ANY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_ANY | MAY_BE_ARRAY_OF_REF;
+                               t1 = zend_fetch_prop_type(script, prop_info, &ce);
                                t2 = OP1_DATA_INFO();
                        } else if (opline->extended_value == ZEND_ASSIGN_DIM) {
                                if (t1 & MAY_BE_ARRAY_OF_REF) {
@@ -2489,6 +2610,10 @@ static int zend_update_type_info(const zend_op_array *op_array,
                                orig = t1;
                                t1 = zend_array_element_type(t1, 1, 0);
                                t2 = OP1_DATA_INFO();
+                       } else if (opline->extended_value == ZEND_ASSIGN_STATIC_PROP) {
+                               prop_info = zend_fetch_static_prop_info(script, op_array, ssa, opline);
+                               t1 = zend_fetch_prop_type(script, prop_info, &ce);
+                               t2 = OP1_DATA_INFO();
                        } else {
                                if (t1 & MAY_BE_REF) {
                                tmp |= MAY_BE_REF;
@@ -2524,10 +2649,13 @@ static int zend_update_type_info(const zend_op_array *op_array,
                                        UPDATE_SSA_TYPE(orig, ssa_ops[i].op1_def);
                                        COPY_SSA_OBJ_TYPE(ssa_ops[i].op1_use, ssa_ops[i].op1_def);
                                }
+                       } else if (opline->extended_value == ZEND_ASSIGN_STATIC_PROP) {
+                               /* Nothing to do */
                        } else {
                                UPDATE_SSA_TYPE(tmp, ssa_ops[i].op1_def);
                        }
                        if (ssa_ops[i].result_def >= 0) {
+                               ce = NULL;
                                if (opline->extended_value == ZEND_ASSIGN_DIM) {
                                        if (opline->op2_type == IS_UNUSED) {
                                                /* When appending to an array and the LONG_MAX key is already used
@@ -2549,10 +2677,25 @@ static int zend_update_type_info(const zend_op_array *op_array,
                                                 * anything else results in a null return value. */
                                                tmp |= MAY_BE_NULL;
                                        }
+
+                                       /* The return value must also satisfy the property type */
+                                       if (prop_info) {
+                                               tmp &= zend_fetch_prop_type(script, prop_info, NULL);
+                                       }
+                               } else if (opline->extended_value == ZEND_ASSIGN_STATIC_PROP) {
+                                       /* The return value must also satisfy the property type */
+                                       if (prop_info) {
+                                               tmp &= zend_fetch_prop_type(script, prop_info, NULL);
+                                       }
                                }
+                               tmp &= ~MAY_BE_REF;
                                UPDATE_SSA_TYPE(tmp, ssa_ops[i].result_def);
+                               if (ce) {
+                                       UPDATE_SSA_OBJ_TYPE(ce, 1, ssa_ops[i].result_def);
+                               }
                        }
                        break;
+               }
                case ZEND_PRE_INC:
                case ZEND_PRE_DEC:
                        tmp = 0;
@@ -2727,9 +2870,13 @@ static int zend_update_type_info(const zend_op_array *op_array,
                                COPY_SSA_OBJ_TYPE(ssa_ops[i].op1_use, ssa_ops[i].op1_def);
                        }
                        if (ssa_ops[i].result_def >= 0) {
-                               // TODO: ???
-                               tmp = MAY_BE_REF | MAY_BE_RC1 | MAY_BE_RCN | MAY_BE_ANY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_ANY | MAY_BE_ARRAY_OF_REF;
+                               // TODO: If there is no __set we might do better
+                               tmp = zend_fetch_prop_type(script,
+                                       zend_fetch_prop_info(op_array, ssa, opline, i), &ce);
                                UPDATE_SSA_TYPE(tmp, ssa_ops[i].result_def);
+                               if (ce) {
+                                       UPDATE_SSA_OBJ_TYPE(ce, 1, ssa_ops[i].result_def);
+                               }
                        }
                        if ((opline+1)->op1_type == IS_CV) {
                                opline++;
@@ -2827,6 +2974,42 @@ static int zend_update_type_info(const zend_op_array *op_array,
                                UPDATE_SSA_TYPE(tmp, ssa_ops[i].result_def);
                        }
                        break;
+               case ZEND_ASSIGN_OBJ_REF:
+                       if (opline->op1_type == IS_CV) {
+                               tmp = t1;
+                               if (t1 & (MAY_BE_UNDEF|MAY_BE_NULL|MAY_BE_FALSE)) {
+                                       tmp &= ~(MAY_BE_UNDEF|MAY_BE_NULL|MAY_BE_FALSE);
+                                       tmp |= MAY_BE_OBJECT | MAY_BE_RC1 | MAY_BE_RCN;
+                               }
+                               if (tmp & MAY_BE_OBJECT) {
+                                       tmp |= MAY_BE_RC1 | MAY_BE_RCN;
+                               }
+                               UPDATE_SSA_TYPE(tmp, ssa_ops[i].op1_def);
+                               COPY_SSA_OBJ_TYPE(ssa_ops[i].op1_use, ssa_ops[i].op1_def);
+                       }
+
+                       t2 = OP1_DATA_INFO();
+                       if ((opline+1)->op1_type == IS_VAR && (opline->extended_value & ZEND_RETURNS_FUNCTION)) {
+                               tmp = (MAY_BE_REF | MAY_BE_RCN | MAY_BE_RC1 | t2) & ~MAY_BE_UNDEF;
+                       } else {
+                               tmp = (MAY_BE_REF | t2) & ~(MAY_BE_UNDEF|MAY_BE_ERROR|MAY_BE_RC1|MAY_BE_RCN);
+                       }
+                       if (t2 & MAY_BE_UNDEF) {
+                               tmp |= MAY_BE_NULL;
+                       }
+                       if (ssa_ops[i].result_def >= 0) {
+                               UPDATE_SSA_TYPE(tmp, ssa_ops[i].result_def);
+                       }
+                       if ((opline+1)->op1_type == IS_CV) {
+                               opline++;
+                               i++;
+                               tmp = (MAY_BE_REF | t2) & ~(MAY_BE_UNDEF|MAY_BE_RC1|MAY_BE_RCN);
+                               if (t2 & MAY_BE_UNDEF) {
+                                       tmp |= MAY_BE_NULL;
+                               }
+                               UPDATE_SSA_TYPE(tmp, ssa_ops[i].op1_def);
+                       }
+                       break;
                case ZEND_BIND_GLOBAL:
                        tmp = MAY_BE_REF | MAY_BE_ANY
                                | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_ANY | MAY_BE_ARRAY_OF_REF;
@@ -3245,6 +3428,7 @@ static int zend_update_type_info(const zend_op_array *op_array,
                                                case ZEND_FETCH_OBJ_RW:
                                                case ZEND_FETCH_OBJ_FUNC_ARG:
                                                case ZEND_ASSIGN_OBJ:
+                                               case ZEND_ASSIGN_OBJ_REF:
                                                case ZEND_PRE_INC_OBJ:
                                                case ZEND_PRE_DEC_OBJ:
                                                case ZEND_POST_INC_OBJ:
@@ -3342,14 +3526,31 @@ static int zend_update_type_info(const zend_op_array *op_array,
                                COPY_SSA_OBJ_TYPE(ssa_ops[i].op1_use, ssa_ops[i].op1_def);
                        }
                        if (ssa_ops[i].result_def >= 0) {
-                               tmp = MAY_BE_ANY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_ANY | MAY_BE_ARRAY_OF_REF;
-                               if (opline->result_type == IS_TMP_VAR) {
-                                       /* can't be REF  because of ZVAL_COPY_DEREF() usage */
-                                       tmp |= MAY_BE_RC1 | MAY_BE_RCN;
-                               } else {
-                                       tmp |= MAY_BE_REF | MAY_BE_RC1 | MAY_BE_RCN | MAY_BE_ERROR;
+                               tmp = zend_fetch_prop_type(script,
+                                       zend_fetch_prop_info(op_array, ssa, opline, i), &ce);
+                               if (opline->result_type != IS_TMP_VAR) {
+                                       tmp |= MAY_BE_REF | MAY_BE_ERROR;
                                }
                                UPDATE_SSA_TYPE(tmp, ssa_ops[i].result_def);
+                               if (ce) {
+                                       UPDATE_SSA_OBJ_TYPE(ce, 1, ssa_ops[i].result_def);
+                               }
+                       }
+                       break;
+               case ZEND_FETCH_STATIC_PROP_R:
+               case ZEND_FETCH_STATIC_PROP_IS:
+               case ZEND_FETCH_STATIC_PROP_RW:
+               case ZEND_FETCH_STATIC_PROP_W:
+               case ZEND_FETCH_STATIC_PROP_UNSET:
+               case ZEND_FETCH_STATIC_PROP_FUNC_ARG:
+                       tmp = zend_fetch_prop_type(script,
+                               zend_fetch_static_prop_info(script, op_array, ssa, opline), &ce);
+                       if (opline->result_type != IS_TMP_VAR) {
+                               tmp |= MAY_BE_REF | MAY_BE_ERROR;
+                       }
+                       UPDATE_SSA_TYPE(tmp, ssa_ops[i].result_def);
+                       if (ce) {
+                               UPDATE_SSA_OBJ_TYPE(ce, 1, ssa_ops[i].result_def);
                        }
                        break;
                case ZEND_DO_FCALL:
@@ -4182,7 +4383,7 @@ int zend_may_throw(const zend_op *opline, zend_op_array *op_array, zend_ssa *ssa
                                        return 1;
                        }
                }
-    } else if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
+       } else if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
                if (t1 & (MAY_BE_OBJECT|MAY_BE_RESOURCE|MAY_BE_ARRAY_OF_OBJECT|MAY_BE_ARRAY_OF_RESOURCE|MAY_BE_ARRAY_OF_ARRAY)) {
                        switch (opline->opcode) {
                                case ZEND_CASE:
@@ -4206,9 +4407,9 @@ int zend_may_throw(const zend_op *opline, zend_op_array *op_array, zend_ssa *ssa
                                        return 1;
                        }
                }
-    }
+       }
 
-    if (opline->op2_type == IS_CV) {
+       if (opline->op2_type == IS_CV) {
                if (t2 & MAY_BE_UNDEF) {
                        switch (opline->opcode) {
                                case ZEND_ASSIGN_REF:
@@ -4228,7 +4429,7 @@ int zend_may_throw(const zend_op *opline, zend_op_array *op_array, zend_ssa *ssa
                                        return 1;
                        }
                }
-    }
+       }
 
        switch (opline->opcode) {
                case ZEND_NOP:
@@ -4390,6 +4591,9 @@ int zend_may_throw(const zend_op *opline, zend_op_array *op_array, zend_ssa *ssa
                        return (t1 & (MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_OBJECT)) ||
                                (t2 & (MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_OBJECT));
                case ZEND_ASSIGN:
+                       if (t1 & MAY_BE_REF) {
+                               return 1;
+                       }
                case ZEND_UNSET_VAR:
                        return (t1 & (MAY_BE_OBJECT|MAY_BE_RESOURCE|MAY_BE_ARRAY_OF_OBJECT|MAY_BE_ARRAY_OF_RESOURCE|MAY_BE_ARRAY_OF_ARRAY));
                case ZEND_ASSIGN_DIM:

diff --git a/ext/opcache/Optimizer/zend_optimizer.c b/ext/opcache/Optimizer/zend_optimizer.c
index d13b8a000e197e4bdbcfc597b76eeb2afce44f54..42cd5eef8fce4036a0c1a441473abb670d38a5f1 100644 (file)
--- a/ext/opcache/Optimizer/zend_optimizer.c
+++ b/ext/opcache/Optimizer/zend_optimizer.c
@@ -256,6 +256,14 @@ int zend_optimizer_update_op1_const(zend_op_array *op_array,
                                     zval          *val)
 {
        switch (opline->opcode) {
+               case ZEND_OP_DATA:
+                       switch ((opline-1)->opcode) {
+                               case ZEND_ASSIGN_OBJ_REF:
+                               case ZEND_ASSIGN_STATIC_PROP_REF:
+                                       return 0;
+                       }
+                       opline->op1.constant = zend_optimizer_add_literal(op_array, val);
+                       break;
                case ZEND_FREE:
                case ZEND_CHECK_VAR:
                        MAKE_NOP(opline);
@@ -312,6 +320,23 @@ int zend_optimizer_update_op1_const(zend_op_array *op_array,
                        }
                        zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
                        break;
+               case ZEND_ASSIGN_ADD:
+               case ZEND_ASSIGN_SUB:
+               case ZEND_ASSIGN_MUL:
+               case ZEND_ASSIGN_DIV:
+               case ZEND_ASSIGN_MOD:
+               case ZEND_ASSIGN_SL:
+               case ZEND_ASSIGN_SR:
+               case ZEND_ASSIGN_CONCAT:
+               case ZEND_ASSIGN_BW_OR:
+               case ZEND_ASSIGN_BW_AND:
+               case ZEND_ASSIGN_BW_XOR:
+               case ZEND_ASSIGN_POW:
+                       if (opline->extended_value != ZEND_ASSIGN_STATIC_PROP) {
+                               break;
+                       }
+               case ZEND_ASSIGN_STATIC_PROP:
+               case ZEND_ASSIGN_STATIC_PROP_REF:
                case ZEND_FETCH_STATIC_PROP_R:
                case ZEND_FETCH_STATIC_PROP_W:
                case ZEND_FETCH_STATIC_PROP_RW:
@@ -319,21 +344,17 @@ int zend_optimizer_update_op1_const(zend_op_array *op_array,
                case ZEND_FETCH_STATIC_PROP_UNSET:
                case ZEND_FETCH_STATIC_PROP_FUNC_ARG:
                case ZEND_UNSET_STATIC_PROP:
-                       TO_STRING_NOWARN(val);
-                       opline->op1.constant = zend_optimizer_add_literal(op_array, val);
-                       if (opline->op2_type == IS_CONST && opline->extended_value + sizeof(void*) == op_array->cache_size) {
-                               op_array->cache_size += sizeof(void *);
-                       } else {
-                               opline->extended_value = alloc_cache_slots(op_array, 2);
-                       }
-                       break;
                case ZEND_ISSET_ISEMPTY_STATIC_PROP:
+               case ZEND_PRE_INC_STATIC_PROP:
+               case ZEND_PRE_DEC_STATIC_PROP:
+               case ZEND_POST_INC_STATIC_PROP:
+               case ZEND_POST_DEC_STATIC_PROP:
                        TO_STRING_NOWARN(val);
                        opline->op1.constant = zend_optimizer_add_literal(op_array, val);
-                       if (opline->op2_type == IS_CONST && (opline->extended_value & ~ZEND_ISEMPTY) + sizeof(void*) == op_array->cache_size) {
+                       if (opline->op2_type == IS_CONST && (opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) + sizeof(void*) == op_array->cache_size) {
                                op_array->cache_size += sizeof(void *);
                        } else {
-                               opline->extended_value = alloc_cache_slots(op_array, 2) | (opline->extended_value & ZEND_ISEMPTY);
+                               opline->extended_value = alloc_cache_slots(op_array, 3) | (opline->extended_value & ZEND_FETCH_OBJ_FLAGS);
                        }
                        break;
                case ZEND_SEND_VAR:
@@ -405,6 +426,8 @@ int zend_optimizer_update_op2_const(zend_op_array *op_array,
                        zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
                        opline->result.num = alloc_cache_slots(op_array, 1);
                        break;
+               case ZEND_ASSIGN_STATIC_PROP:
+               case ZEND_ASSIGN_STATIC_PROP_REF:
                case ZEND_FETCH_STATIC_PROP_R:
                case ZEND_FETCH_STATIC_PROP_W:
                case ZEND_FETCH_STATIC_PROP_RW:
@@ -412,21 +435,17 @@ int zend_optimizer_update_op2_const(zend_op_array *op_array,
                case ZEND_FETCH_STATIC_PROP_UNSET:
                case ZEND_FETCH_STATIC_PROP_FUNC_ARG:
                case ZEND_UNSET_STATIC_PROP:
+               case ZEND_PRE_INC_STATIC_PROP:
+               case ZEND_PRE_DEC_STATIC_PROP:
+               case ZEND_POST_INC_STATIC_PROP:
+               case ZEND_POST_DEC_STATIC_PROP:
+handle_static_prop:
                        REQUIRES_STRING(val);
                        drop_leading_backslash(val);
                        opline->op2.constant = zend_optimizer_add_literal(op_array, val);
                        zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
                        if (opline->op1_type != IS_CONST) {
-                               opline->extended_value = alloc_cache_slots(op_array, 1);
-                       }
-                       break;
-               case ZEND_ISSET_ISEMPTY_STATIC_PROP:
-                       REQUIRES_STRING(val);
-                       drop_leading_backslash(val);
-                       opline->op2.constant = zend_optimizer_add_literal(op_array, val);
-                       zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
-                       if (opline->op1_type != IS_CONST) {
-                               opline->extended_value = alloc_cache_slots(op_array, 1) | (opline->extended_value & ZEND_ISEMPTY);
+                               opline->extended_value = alloc_cache_slots(op_array, 1) | (opline->extended_value & (ZEND_RETURNS_FUNCTION|ZEND_ISEMPTY|ZEND_FETCH_OBJ_FLAGS));
                        }
                        break;
                case ZEND_INIT_FCALL:
@@ -477,6 +496,7 @@ int zend_optimizer_update_op2_const(zend_op_array *op_array,
                        }
                        break;
                case ZEND_ASSIGN_OBJ:
+               case ZEND_ASSIGN_OBJ_REF:
                case ZEND_FETCH_OBJ_R:
                case ZEND_FETCH_OBJ_W:
                case ZEND_FETCH_OBJ_RW:
@@ -490,12 +510,12 @@ int zend_optimizer_update_op2_const(zend_op_array *op_array,
                case ZEND_POST_DEC_OBJ:
                        TO_STRING_NOWARN(val);
                        opline->op2.constant = zend_optimizer_add_literal(op_array, val);
-                       opline->extended_value = alloc_cache_slots(op_array, 2);
+                       opline->extended_value = alloc_cache_slots(op_array, 3);
                        break;
                case ZEND_ISSET_ISEMPTY_PROP_OBJ:
                        TO_STRING_NOWARN(val);
                        opline->op2.constant = zend_optimizer_add_literal(op_array, val);
-                       opline->extended_value = alloc_cache_slots(op_array, 2) | (opline->extended_value & ZEND_ISEMPTY);
+                       opline->extended_value = alloc_cache_slots(op_array, 3) | (opline->extended_value & ZEND_ISEMPTY);
                        break;
                case ZEND_ASSIGN_ADD:
                case ZEND_ASSIGN_SUB:
@@ -512,7 +532,9 @@ int zend_optimizer_update_op2_const(zend_op_array *op_array,
                        if (opline->extended_value == ZEND_ASSIGN_OBJ) {
                                TO_STRING_NOWARN(val);
                                opline->op2.constant = zend_optimizer_add_literal(op_array, val);
-                               (opline+1)->extended_value = alloc_cache_slots(op_array, 2);
+                               (opline+1)->extended_value = alloc_cache_slots(op_array, 3);
+                       } else if (opline->extended_value == ZEND_ASSIGN_STATIC_PROP) {
+                               goto handle_static_prop;
                        } else if (opline->extended_value == ZEND_ASSIGN_DIM) {
                                if (Z_TYPE_P(val) == IS_STRING) {
                                        zend_ulong index;

diff --git a/ext/opcache/Optimizer/zend_ssa.c b/ext/opcache/Optimizer/zend_ssa.c
index ea387bb95fdd23f65410fd9428cad3dff6ffd6d6..ad34e7f643c68d91e855d3815ed9c7c6d96c74ba 100644 (file)
--- a/ext/opcache/Optimizer/zend_ssa.c
+++ b/ext/opcache/Optimizer/zend_ssa.c
@@ -642,6 +642,22 @@ static int zend_ssa_rename(const zend_op_array *op_array, uint32_t build_flags,
                                                //NEW_SSA_VAR(next->op1.var)
                                        }
                                        break;
+                               case ZEND_ASSIGN_OBJ_REF:
+                                       if (opline->op1_type == IS_CV) {
+                                               ssa_ops[k].op1_def = ssa_vars_count;
+                                               var[EX_VAR_TO_NUM(opline->op1.var)] = ssa_vars_count;
+                                               ssa_vars_count++;
+                                               //NEW_SSA_VAR(opline->op1.var)
+                                       }
+                                       /* break missing intentionally */
+                               case ZEND_ASSIGN_STATIC_PROP_REF:
+                                       if (next->op1_type == IS_CV) {
+                                               ssa_ops[k + 1].op1_def = ssa_vars_count;
+                                               var[EX_VAR_TO_NUM(next->op1.var)] = ssa_vars_count;
+                                               ssa_vars_count++;
+                                               //NEW_SSA_VAR(next->op1.var)
+                                       }
+                                       break;
                                case ZEND_PRE_INC_OBJ:
                                case ZEND_PRE_DEC_OBJ:
                                case ZEND_POST_INC_OBJ:

diff --git a/ext/opcache/tests/opt/prop_types.phpt b/ext/opcache/tests/opt/prop_types.phpt
new file mode 100644 (file)
index 0000000..7962b1b
--- /dev/null
+++ b/ext/opcache/tests/opt/prop_types.phpt
@@ -0,0 +1,115 @@
+--TEST--
+Property types in inference
+--INI--
+opcache.enable=1
+opcache.enable_cli=1
+opcache.optimization_level=-1
+opcache.opt_debug_level=0x200000
+--SKIPIF--
+<?php require_once('skipif.inc'); ?>
+--FILE--
+<?php
+
+class Test {
+    public bool $public;
+    protected int $protected;
+    private float $private;
+
+    public function inTest() {
+        var_dump($this->public, $this->protected, $this->private);
+    }
+
+    public function inTestWithTest2(Test2 $test2) {
+        var_dump($test2->public, $test2->protected, $test2->private);
+    }
+}
+
+class Test2 extends Test {
+    private array $private;
+
+    public function inTest2() {
+        var_dump($this->public, $this->protected, $this->private);
+    }
+}
+
+function noScope(Test $test) {
+    var_dump($test->public, $test->protected, $test->private);
+}
+
+?>
+--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
+            RETURN int(1)
+
+noScope: ; (lines=10, args=1, vars=1, tmps=1, ssa_vars=5, no_loops)
+    ; (before dfa pass)
+    ; %s
+    ; return  [null] RANGE[0..0]
+    ; #0.CV0($test) NOVAL [undef]
+BB0: start exit lines=[0-9]
+    ; level=0
+            #1.CV0($test) [object (instanceof Test)] = RECV 1
+            INIT_FCALL 3 128 string("var_dump")
+            #2.T1 [bool] = FETCH_OBJ_R #1.CV0($test) [object (instanceof Test)] string("public")
+            SEND_VAL #2.T1 [bool] 1
+            #3.T1 [any] = FETCH_OBJ_R #1.CV0($test) [object (instanceof Test)] string("protected")
+            SEND_VAL #3.T1 [any] 2
+            #4.T1 [any] = FETCH_OBJ_R #1.CV0($test) [object (instanceof Test)] string("private")
+            SEND_VAL #4.T1 [any] 3
+            DO_ICALL
+            RETURN null
+
+Test::inTest: ; (lines=9, args=0, vars=0, tmps=1, ssa_vars=3, no_loops)
+    ; (before dfa pass)
+    ; %s
+    ; return  [null] RANGE[0..0]
+BB0: start exit lines=[0-8]
+    ; level=0
+            INIT_FCALL 3 128 string("var_dump")
+            #0.T0 [bool] = FETCH_OBJ_R THIS string("public")
+            SEND_VAL #0.T0 [bool] 1
+            #1.T0 [long] = FETCH_OBJ_R THIS string("protected")
+            SEND_VAL #1.T0 [long] 2
+            #2.T0 [double] = FETCH_OBJ_R THIS string("private")
+            SEND_VAL #2.T0 [double] 3
+            DO_ICALL
+            RETURN null
+
+Test::inTestWithTest2: ; (lines=10, args=1, vars=1, tmps=1, ssa_vars=5, no_loops)
+    ; (before dfa pass)
+    ; %s
+    ; return  [null] RANGE[0..0]
+    ; #0.CV0($test2) NOVAL [undef]
+BB0: start exit lines=[0-9]
+    ; level=0
+            #1.CV0($test2) [object (instanceof Test2)] = RECV 1
+            INIT_FCALL 3 128 string("var_dump")
+            #2.T1 [bool] = FETCH_OBJ_R #1.CV0($test2) [object (instanceof Test2)] string("public")
+            SEND_VAL #2.T1 [bool] 1
+            #3.T1 [long] = FETCH_OBJ_R #1.CV0($test2) [object (instanceof Test2)] string("protected")
+            SEND_VAL #3.T1 [long] 2
+            #4.T1 [double] = FETCH_OBJ_R #1.CV0($test2) [object (instanceof Test2)] string("private")
+            SEND_VAL #4.T1 [double] 3
+            DO_ICALL
+            RETURN null
+
+Test2::inTest2: ; (lines=9, args=0, vars=0, tmps=1, ssa_vars=3, no_loops)
+    ; (before dfa pass)
+    ; %s
+    ; return  [null] RANGE[0..0]
+BB0: start exit lines=[0-8]
+    ; level=0
+            INIT_FCALL 3 128 string("var_dump")
+            #0.T0 [bool] = FETCH_OBJ_R THIS string("public")
+            SEND_VAL #0.T0 [bool] 1
+            #1.T0 [long] = FETCH_OBJ_R THIS string("protected")
+            SEND_VAL #1.T0 [long] 2
+            #2.T0 [array of [any, ref]] = FETCH_OBJ_R THIS string("private")
+            SEND_VAL #2.T0 [array of [any, ref]] 3
+            DO_ICALL
+            RETURN null

diff --git a/ext/opcache/zend_accelerator_util_funcs.c b/ext/opcache/zend_accelerator_util_funcs.c
index d22cc7ffd7c23049e0c69be16a6ba68a510f6d76..7b04d0d2df44b42d4b6e152ef1bc0fdd498ab0d3 100644 (file)
--- a/ext/opcache/zend_accelerator_util_funcs.c
+++ b/ext/opcache/zend_accelerator_util_funcs.c
@@ -232,6 +232,14 @@ static void zend_hash_clone_prop_info(HashTable *ht)
                        if (IN_ARENA(prop_info->ce)) {
                                prop_info->ce = ARENA_REALLOC(prop_info->ce);
                        }
+
+                       if (ZEND_TYPE_IS_CE(prop_info->type)) {
+                               zend_class_entry *ce = ZEND_TYPE_CE(prop_info->type);
+                               if (IN_ARENA(ce)) {
+                                       ce = ARENA_REALLOC(ce);
+                                       prop_info->type = ZEND_TYPE_ENCODE_CE(ce, ZEND_TYPE_ALLOW_NULL(prop_info->type));
+                               }
+                       }
                }
        }
 }
@@ -304,6 +312,16 @@ static void zend_class_copy_ctor(zend_class_entry **pce)
        /* constants table */
        zend_hash_clone_constants(&ce->constants_table);
 
+       if (ce->properties_info_table) {
+               int i;
+               ce->properties_info_table = ARENA_REALLOC(ce->properties_info_table);
+               for (i = 0; i < ce->default_properties_count; i++) {
+                       if (IN_ARENA(ce->properties_info_table[i])) {
+                               ce->properties_info_table[i] = ARENA_REALLOC(ce->properties_info_table[i]);
+                       }
+               }
+       }
+
        if (ce->num_interfaces) {
                zend_class_name *interface_names;
 

diff --git a/ext/opcache/zend_file_cache.c b/ext/opcache/zend_file_cache.c
index 86cb8a2e259d66f88e0afd26c51c1bdd6d0ed2f8..92a77ab7929b1e44b530b3a8588a764b50a4e731 100644 (file)
--- a/ext/opcache/zend_file_cache.c
+++ b/ext/opcache/zend_file_cache.c
@@ -577,6 +577,17 @@ static void zend_file_cache_serialize_prop_info(zval                     *zv,
                                SERIALIZE_STR(prop->doc_comment);
                        }
                }
+               if (prop->type) {
+                       if (ZEND_TYPE_IS_NAME(prop->type)) {
+                               zend_string *name = ZEND_TYPE_NAME(prop->type);
+                               SERIALIZE_STR(name);
+                               prop->type = ZEND_TYPE_ENCODE_CLASS(name, ZEND_TYPE_ALLOW_NULL(prop->type));
+                       } else if (ZEND_TYPE_IS_CE(prop->type)) {
+                               zend_class_entry *ce = ZEND_TYPE_CE(prop->type);
+                               SERIALIZE_PTR(ce);
+                               prop->type = ZEND_TYPE_ENCODE_CE(ce, ZEND_TYPE_ALLOW_NULL(prop->type));
+                       }
+               }
        }
 }
 
@@ -660,6 +671,19 @@ static void zend_file_cache_serialize_class(zval                     *zv,
        SERIALIZE_STR(ce->info.user.doc_comment);
        zend_file_cache_serialize_hash(&ce->properties_info, script, info, buf, zend_file_cache_serialize_prop_info);
 
+       if (ce->properties_info_table) {
+               uint32_t i;
+               zend_property_info **table;
+
+               SERIALIZE_PTR(ce->properties_info_table);
+               table = ce->properties_info_table;
+               UNSERIALIZE_PTR(table);
+
+               for (i = 0; i < ce->default_properties_count; i++) {
+                       SERIALIZE_PTR(table[i]);
+               }
+       }
+
        if (ce->num_interfaces) {
                uint32_t i;
                zend_class_name *interface_names;
@@ -1246,6 +1270,17 @@ static void zend_file_cache_unserialize_prop_info(zval                    *zv,
                                UNSERIALIZE_STR(prop->doc_comment);
                        }
                }
+               if (prop->type) {
+                       if (ZEND_TYPE_IS_NAME(prop->type)) {
+                               zend_string *name = ZEND_TYPE_NAME(prop->type);
+                               UNSERIALIZE_STR(name);
+                               prop->type = ZEND_TYPE_ENCODE_CLASS(name, ZEND_TYPE_ALLOW_NULL(prop->type));
+                       } else if (ZEND_TYPE_IS_CE(prop->type)) {
+                               zend_class_entry *ce = ZEND_TYPE_CE(prop->type);
+                               UNSERIALIZE_PTR(ce);
+                               prop->type = ZEND_TYPE_ENCODE_CE(ce, ZEND_TYPE_ALLOW_NULL(prop->type));
+                       }
+               }
        }
 }
 
@@ -1325,6 +1360,15 @@ static void zend_file_cache_unserialize_class(zval                    *zv,
        zend_file_cache_unserialize_hash(&ce->properties_info,
                        script, buf, zend_file_cache_unserialize_prop_info, NULL);
 
+       if (ce->properties_info_table) {
+               uint32_t i;
+               UNSERIALIZE_PTR(ce->properties_info_table);
+
+               for (i = 0; i < ce->default_properties_count; i++) {
+                       UNSERIALIZE_PTR(ce->properties_info_table[i]);
+               }
+       }
+
        if (ce->num_interfaces) {
                uint32_t i;
 

diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c
index eba9dd23e4d6120a7dd25d9ed34a6759fdca55f1..af9244bbf58d06c9a05a1e1833a40988b58e2fed 100644 (file)
--- a/ext/opcache/zend_persist.c
+++ b/ext/opcache/zend_persist.c
@@ -746,6 +746,16 @@ static void zend_persist_property_info(zval *zv)
                        prop->doc_comment = NULL;
                }
        }
+
+       if (ZEND_TYPE_IS_NAME(prop->type)) {
+               zend_string *class_name = ZEND_TYPE_NAME(prop->type);
+               zend_accel_store_interned_string(class_name);
+               prop->type = ZEND_TYPE_ENCODE_CLASS(class_name, ZEND_TYPE_ALLOW_NULL(prop->type));
+       } else if (ZEND_TYPE_IS_CE(prop->type)) {
+               zend_class_entry *ce = ZEND_TYPE_CE(prop->type);
+               ce = zend_shared_alloc_get_xlat_entry(ce);
+               prop->type = ZEND_TYPE_ENCODE_CE(ce, ZEND_TYPE_ALLOW_NULL(prop->type));
+       }
 }
 
 static void zend_persist_class_constant(zval *zv)
@@ -786,6 +796,16 @@ static void zend_persist_class_constant(zval *zv)
        }
 }
 
+static zend_bool has_unresolved_property_types(zend_class_entry *ce) {
+       zend_property_info *prop;
+       ZEND_HASH_FOREACH_PTR(&ce->properties_info, prop) {
+               if (ZEND_TYPE_IS_NAME(prop->type)) {
+                       return 1;
+               }
+       } ZEND_HASH_FOREACH_END();
+       return 0;
+}
+
 static void zend_persist_class_entry(zval *zv)
 {
        zend_class_entry *ce = Z_PTR_P(zv);
@@ -793,6 +813,7 @@ static void zend_persist_class_entry(zval *zv)
        if (ce->type == ZEND_USER_CLASS) {
                if ((ce->ce_flags & ZEND_ACC_LINKED)
                 && (ce->ce_flags & ZEND_ACC_CONSTANTS_UPDATED)
+                && !has_unresolved_property_types(ce)
                 && !ZCG(current_persistent_script)->corrupted) {
                        ZCG(is_immutable_class) = 1;
                        ce = Z_PTR_P(zv) = zend_shared_memdup_put(ce, sizeof(zend_class_entry));
@@ -855,6 +876,19 @@ static void zend_persist_class_entry(zval *zv)
                zend_hash_persist(&ce->properties_info, zend_persist_property_info);
                HT_FLAGS(&ce->properties_info) &= (HASH_FLAG_UNINITIALIZED | HASH_FLAG_STATIC_KEYS);
 
+               if (ce->properties_info_table) {
+                       int i;
+
+                       size_t size = sizeof(zend_property_info *) * ce->default_properties_count;
+                       memcpy(ZCG(arena_mem), ce->properties_info_table, size);
+                       ce->properties_info_table = ZCG(arena_mem);
+                       ZCG(arena_mem) = (void*)((char*)ZCG(arena_mem) + ZEND_ALIGNED_SIZE(size));
+
+                       for (i = 0; i < ce->default_properties_count; i++) {
+                               ce->properties_info_table[i] = zend_shared_alloc_get_xlat_entry(ce->properties_info_table[i]);
+                       }
+               }
+
                if (ce->num_interfaces && !(ce->ce_flags & ZEND_ACC_LINKED)) {
                        uint32_t i = 0;
 

diff --git a/ext/opcache/zend_persist_calc.c b/ext/opcache/zend_persist_calc.c
index 5fd48a224e993f6864c2005d05e795860fb875a9..a17d7c4627f6aac6f383d1b73a5b4c94a1a0c4f2 100644 (file)
--- a/ext/opcache/zend_persist_calc.c
+++ b/ext/opcache/zend_persist_calc.c
@@ -306,6 +306,11 @@ static void zend_persist_property_info_calc(zval *zv)
                zend_shared_alloc_register_xlat_entry(prop, prop);
                ADD_SIZE_EX(sizeof(zend_property_info));
                ADD_INTERNED_STRING(prop->name);
+               if (ZEND_TYPE_IS_NAME(prop->type)) {
+                       zend_string *class_name = ZEND_TYPE_NAME(prop->type);
+                       ADD_INTERNED_STRING(class_name);
+                       prop->type = ZEND_TYPE_ENCODE_CLASS(class_name, ZEND_TYPE_ALLOW_NULL(prop->type));
+               }
                if (ZCG(accel_directives).save_comments && prop->doc_comment) {
                        ADD_STRING(prop->doc_comment);
                }
@@ -326,6 +331,16 @@ static void zend_persist_class_constant_calc(zval *zv)
        }
 }
 
+static zend_bool has_unresolved_property_types(zend_class_entry *ce) {
+       zend_property_info *prop;
+       ZEND_HASH_FOREACH_PTR(&ce->properties_info, prop) {
+               if (ZEND_TYPE_IS_NAME(prop->type)) {
+                       return 1;
+               }
+       } ZEND_HASH_FOREACH_END();
+       return 0;
+}
+
 static void zend_persist_class_entry_calc(zval *zv)
 {
        zend_class_entry *ce = Z_PTR_P(zv);
@@ -334,6 +349,7 @@ static void zend_persist_class_entry_calc(zval *zv)
                ZCG(is_immutable_class) =
                        (ce->ce_flags & ZEND_ACC_LINKED) &&
                        (ce->ce_flags & ZEND_ACC_CONSTANTS_UPDATED) &&
+                       !has_unresolved_property_types(ce) &&
                        !ZCG(current_persistent_script)->corrupted;
 
                ADD_SIZE_EX(sizeof(zend_class_entry));
@@ -371,6 +387,10 @@ static void zend_persist_class_entry_calc(zval *zv)
 
                zend_hash_persist_calc(&ce->properties_info, zend_persist_property_info_calc);
 
+               if (ce->properties_info_table) {
+                       ADD_ARENA_SIZE(sizeof(zend_property_info *) * ce->default_properties_count);
+               }
+
                if (ce->num_interfaces) {
                        uint32_t i;
 

diff --git a/ext/openssl/openssl.c b/ext/openssl/openssl.c
index e97cd8fda60d80dda4b14c4f682cf5c582065eda..115801a380c09a3711800bbafdd29c8d4646c6dc 100644 (file)
--- a/ext/openssl/openssl.c
+++ b/ext/openssl/openssl.c
@@ -2101,7 +2101,7 @@ PHP_FUNCTION(openssl_x509_export)
        zend_bool notext = 1;
        BIO * bio_out;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz/|b", &zcert, &zout, &notext) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz|b", &zcert, &zout, &notext) == FAILURE) {
                return;
        }
        RETVAL_FALSE;
@@ -2123,9 +2123,8 @@ PHP_FUNCTION(openssl_x509_export)
        if (PEM_write_bio_X509(bio_out, cert)) {
                BUF_MEM *bio_buf;
 
-               zval_ptr_dtor(zout);
                BIO_get_mem_ptr(bio_out, &bio_buf);
-               ZVAL_STRINGL(zout, bio_buf->data, bio_buf->length);
+               ZEND_TRY_ASSIGN_STRINGL(zout, bio_buf->data, bio_buf->length);
 
                RETVAL_TRUE;
        } else {
@@ -2925,7 +2924,7 @@ PHP_FUNCTION(openssl_pkcs12_export)
        zval * item;
        STACK_OF(X509) *ca = NULL;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz/zs|a", &zcert, &zout, &zpkey, &pass, &pass_len, &args) == FAILURE)
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "zzzs|a", &zcert, &zout, &zpkey, &pass, &pass_len, &args) == FAILURE)
                return;
 
        RETVAL_FALSE;
@@ -2965,9 +2964,8 @@ PHP_FUNCTION(openssl_pkcs12_export)
                if (i2d_PKCS12_bio(bio_out, p12)) {
                        BUF_MEM *bio_buf;
 
-                       zval_ptr_dtor(zout);
                        BIO_get_mem_ptr(bio_out, &bio_buf);
-                       ZVAL_STRINGL(zout, bio_buf->data, bio_buf->length);
+                       ZEND_TRY_ASSIGN_STRINGL(zout, bio_buf->data, bio_buf->length);
 
                        RETVAL_TRUE;
                } else {
@@ -3006,7 +3004,7 @@ PHP_FUNCTION(openssl_pkcs12_read)
        BIO * bio_in = NULL;
        int i;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz/s", &zp12, &zp12_len, &zout, &pass, &pass_len) == FAILURE)
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "szs", &zp12, &zp12_len, &zout, &pass, &pass_len) == FAILURE)
                return;
 
        RETVAL_FALSE;
@@ -3024,8 +3022,10 @@ PHP_FUNCTION(openssl_pkcs12_read)
                BIO * bio_out;
                int cert_num;
 
-               zval_ptr_dtor(zout);
-               array_init(zout);
+               zout = zend_try_array_init(zout);
+               if (!zout) {
+                       goto cleanup;
+               }
 
                if (cert) {
                        bio_out = BIO_new(BIO_s_mem());
@@ -3380,7 +3380,7 @@ PHP_FUNCTION(openssl_csr_export)
        BIO * bio_out;
        zend_resource *csr_resource;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rz/|b", &zcsr, &zout, &notext) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rz|b", &zcsr, &zout, &notext) == FAILURE) {
                return;
        }
 
@@ -3403,8 +3403,7 @@ PHP_FUNCTION(openssl_csr_export)
                BUF_MEM *bio_buf;
 
                BIO_get_mem_ptr(bio_out, &bio_buf);
-               zval_ptr_dtor(zout);
-               ZVAL_STRINGL(zout, bio_buf->data, bio_buf->length);
+               ZEND_TRY_ASSIGN_STRINGL(zout, bio_buf->data, bio_buf->length);
 
                RETVAL_TRUE;
        } else {
@@ -3573,7 +3572,7 @@ PHP_FUNCTION(openssl_csr_new)
        int we_made_the_key = 1;
        zend_resource *key_resource;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "az/|a!a!", &dn, &out_pkey, &args, &attribs) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "az|a!a!", &dn, &out_pkey, &args, &attribs) == FAILURE) {
                return;
        }
        RETVAL_FALSE;
@@ -3581,9 +3580,12 @@ PHP_FUNCTION(openssl_csr_new)
        PHP_SSL_REQ_INIT(&req);
 
        if (PHP_SSL_REQ_PARSE(&req, args) == SUCCESS) {
+               zval *out_pkey_val = out_pkey;
+               ZVAL_DEREF(out_pkey_val);
+
                /* Generate or use a private key */
-               if (Z_TYPE_P(out_pkey) != IS_NULL) {
-                       req.priv_key = php_openssl_evp_from_zval(out_pkey, 0, NULL, 0, 0, &key_resource);
+               if (Z_TYPE_P(out_pkey_val) != IS_NULL) {
+                       req.priv_key = php_openssl_evp_from_zval(out_pkey_val, 0, NULL, 0, 0, &key_resource);
                        if (req.priv_key != NULL) {
                                we_made_the_key = 0;
                        }
@@ -3621,8 +3623,7 @@ PHP_FUNCTION(openssl_csr_new)
 
                                                if (we_made_the_key) {
                                                        /* and a resource for the private key */
-                                                       zval_ptr_dtor(out_pkey);
-                                                       ZVAL_RES(out_pkey, zend_register_resource(req.priv_key, le_key));
+                                                       ZEND_TRY_ASSIGN_RES(out_pkey, zend_register_resource(req.priv_key, le_key));
                                                        req.priv_key = NULL; /* make sure the cleanup code doesn't zap it! */
                                                } else if (key_resource != NULL) {
                                                        req.priv_key = NULL; /* make sure the cleanup code doesn't zap it! */
@@ -4633,7 +4634,7 @@ PHP_FUNCTION(openssl_pkey_export)
        BIO * bio_out = NULL;
        const EVP_CIPHER * cipher;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz/|s!a!", &zpkey, &out, &passphrase, &passphrase_len, &args) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz|s!a!", &zpkey, &out, &passphrase, &passphrase_len, &args) == FAILURE) {
                return;
        }
        RETVAL_FALSE;
@@ -4685,8 +4686,7 @@ PHP_FUNCTION(openssl_pkey_export)
                        RETVAL_TRUE;
 
                        bio_mem_len = BIO_get_mem_data(bio_out, &bio_mem_ptr);
-                       zval_ptr_dtor(out);
-                       ZVAL_STRINGL(out, bio_mem_ptr, bio_mem_len);
+                       ZEND_TRY_ASSIGN_STRINGL(out, bio_mem_ptr, bio_mem_len);
                } else {
                        php_openssl_store_errors();
                }
@@ -5389,7 +5389,7 @@ PHP_FUNCTION(openssl_pkcs7_read)
        PKCS7 * p7 = NULL;
        int i;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz/", &p7b, &p7b_len,
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz", &p7b, &p7b_len,
                                &zout) == FAILURE) {
                return;
        }
@@ -5431,8 +5431,10 @@ PHP_FUNCTION(openssl_pkcs7_read)
                        break;
        }
 
-       zval_ptr_dtor(zout);
-       array_init(zout);
+       zout = zend_try_array_init(zout);
+       if (!zout) {
+               goto clean_exit;
+       }
 
        if (certs != NULL) {
                for (i = 0; i < sk_X509_num(certs); i++) {
@@ -5686,7 +5688,7 @@ PHP_FUNCTION(openssl_private_encrypt)
        size_t data_len;
        zend_long padding = RSA_PKCS1_PADDING;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz/z|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "szz|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
                return;
        }
        RETVAL_FALSE;
@@ -5717,9 +5719,8 @@ PHP_FUNCTION(openssl_private_encrypt)
        }
 
        if (successful) {
-               zval_ptr_dtor(crypted);
                ZSTR_VAL(cryptedbuf)[cryptedlen] = '\0';
-               ZVAL_NEW_STR(crypted, cryptedbuf);
+               ZEND_TRY_ASSIGN_NEW_STR(crypted, cryptedbuf);
                cryptedbuf = NULL;
                RETVAL_TRUE;
        } else {
@@ -5749,7 +5750,7 @@ PHP_FUNCTION(openssl_private_decrypt)
        char * data;
        size_t data_len;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz/z|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "szz|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
                return;
        }
        RETVAL_FALSE;
@@ -5786,9 +5787,8 @@ PHP_FUNCTION(openssl_private_decrypt)
        efree(crypttemp);
 
        if (successful) {
-               zval_ptr_dtor(crypted);
                ZSTR_VAL(cryptedbuf)[cryptedlen] = '\0';
-               ZVAL_NEW_STR(crypted, cryptedbuf);
+               ZEND_TRY_ASSIGN_NEW_STR(crypted, cryptedbuf);
                cryptedbuf = NULL;
                RETVAL_TRUE;
        } else {
@@ -5818,7 +5818,7 @@ PHP_FUNCTION(openssl_public_encrypt)
        char * data;
        size_t data_len;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz/z|l", &data, &data_len, &crypted, &key, &padding) == FAILURE)
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "szz|l", &data, &data_len, &crypted, &key, &padding) == FAILURE)
                return;
        RETVAL_FALSE;
 
@@ -5848,9 +5848,8 @@ PHP_FUNCTION(openssl_public_encrypt)
        }
 
        if (successful) {
-               zval_ptr_dtor(crypted);
                ZSTR_VAL(cryptedbuf)[cryptedlen] = '\0';
-               ZVAL_NEW_STR(crypted, cryptedbuf);
+               ZEND_TRY_ASSIGN_NEW_STR(crypted, cryptedbuf);
                cryptedbuf = NULL;
                RETVAL_TRUE;
        } else {
@@ -5880,7 +5879,7 @@ PHP_FUNCTION(openssl_public_decrypt)
        char * data;
        size_t data_len;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz/z|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "szz|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
                return;
        }
        RETVAL_FALSE;
@@ -5919,9 +5918,8 @@ PHP_FUNCTION(openssl_public_decrypt)
        efree(crypttemp);
 
        if (successful) {
-               zval_ptr_dtor(crypted);
                ZSTR_VAL(cryptedbuf)[cryptedlen] = '\0';
-               ZVAL_NEW_STR(crypted, cryptedbuf);
+               ZEND_TRY_ASSIGN_NEW_STR(crypted, cryptedbuf);
                cryptedbuf = NULL;
                RETVAL_TRUE;
        } else {
@@ -5982,7 +5980,7 @@ PHP_FUNCTION(openssl_sign)
        zend_long signature_algo = OPENSSL_ALGO_SHA1;
        const EVP_MD *mdtype;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz/z|z", &data, &data_len, &signature, &key, &method) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "szz|z", &data, &data_len, &signature, &key, &method) == FAILURE) {
                return;
        }
        pkey = php_openssl_evp_from_zval(key, 0, "", 0, 0, &keyresource);
@@ -6015,10 +6013,9 @@ PHP_FUNCTION(openssl_sign)
                        EVP_SignInit(md_ctx, mdtype) &&
                        EVP_SignUpdate(md_ctx, data, data_len) &&
                        EVP_SignFinal(md_ctx, (unsigned char*)ZSTR_VAL(sigbuf), &siglen, pkey)) {
-               zval_ptr_dtor(signature);
                ZSTR_VAL(sigbuf)[siglen] = '\0';
                ZSTR_LEN(sigbuf) = siglen;
-               ZVAL_NEW_STR(signature, sigbuf);
+               ZEND_TRY_ASSIGN_NEW_STR(signature, sigbuf);
                RETVAL_TRUE;
        } else {
                php_openssl_store_errors();
@@ -6110,7 +6107,7 @@ PHP_FUNCTION(openssl_seal)
        const EVP_CIPHER *cipher;
        EVP_CIPHER_CTX *ctx;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz/z/a|sz/", &data, &data_len,
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "szza|sz", &data, &data_len,
                                &sealdata, &ekeys, &pubkeys, &method, &method_len, &iv) == FAILURE) {
                return;
        }
@@ -6184,12 +6181,15 @@ PHP_FUNCTION(openssl_seal)
        }
 
        if (len1 + len2 > 0) {
-               zval_ptr_dtor(sealdata);
-               ZVAL_NEW_STR(sealdata, zend_string_init((char*)buf, len1 + len2, 0));
+               ZEND_TRY_ASSIGN_NEW_STR(sealdata, zend_string_init((char*)buf, len1 + len2, 0));
                efree(buf);
 
-               zval_ptr_dtor(ekeys);
-               array_init(ekeys);
+               ekeys = zend_try_array_init(ekeys);
+               if (!ekeys) {
+                       EVP_CIPHER_CTX_free(ctx);
+                       goto clean_exit;
+               }
+
                for (i=0; i<nkeys; i++) {
                        eks[i][eksl[i]] = '\0';
                        add_next_index_stringl(ekeys, (const char*)eks[i], eksl[i]);
@@ -6198,9 +6198,8 @@ PHP_FUNCTION(openssl_seal)
                }
 
                if (iv) {
-                       zval_ptr_dtor(iv);
                        iv_buf[iv_len] = '\0';
-                       ZVAL_NEW_STR(iv, zend_string_init((char*)iv_buf, iv_len, 0));
+                       ZEND_TRY_ASSIGN_NEW_STR(iv, zend_string_init((char*)iv_buf, iv_len, 0));
                }
        } else {
                efree(buf);
@@ -6242,7 +6241,7 @@ PHP_FUNCTION(openssl_open)
        size_t method_len = 0, iv_len = 0;
        const EVP_CIPHER *cipher;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz/sz|ss", &data, &data_len, &opendata,
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "szsz|ss", &data, &data_len, &opendata,
                                &ekey, &ekey_len, &privkey, &method, &method_len, &iv, &iv_len) == FAILURE) {
                return;
        }
@@ -6288,9 +6287,8 @@ PHP_FUNCTION(openssl_open)
        if (ctx != NULL && EVP_OpenInit(ctx, cipher, (unsigned char *)ekey, (int)ekey_len, iv_buf, pkey) &&
                        EVP_OpenUpdate(ctx, buf, &len1, (unsigned char *)data, (int)data_len) &&
                        EVP_OpenFinal(ctx, buf + len1, &len2) && (len1 + len2 > 0)) {
-               zval_ptr_dtor(opendata);
                buf[len1 + len2] = '\0';
-               ZVAL_NEW_STR(opendata, zend_string_init((char*)buf, len1 + len2, 0));
+               ZEND_TRY_ASSIGN_NEW_STR(opendata, zend_string_init((char*)buf, len1 + len2, 0));
                RETVAL_TRUE;
        } else {
                php_openssl_store_errors();
@@ -6642,7 +6640,7 @@ PHP_FUNCTION(openssl_encrypt)
        zend_string *outbuf;
        zend_bool free_iv = 0, free_password = 0;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "sss|lsz/sl", &data, &data_len, &method, &method_len,
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "sss|lszsl", &data, &data_len, &method, &method_len,
                                        &password, &password_len, &options, &iv, &iv_len, &tag, &aad, &aad_len, &tag_len) == FAILURE) {
                return;
        }
@@ -6689,10 +6687,9 @@ PHP_FUNCTION(openssl_encrypt)
                        zend_string *tag_str = zend_string_alloc(tag_len, 0);
 
                        if (EVP_CIPHER_CTX_ctrl(cipher_ctx, mode.aead_get_tag_flag, tag_len, ZSTR_VAL(tag_str)) == 1) {
-                               zval_ptr_dtor(tag);
                                ZSTR_VAL(tag_str)[tag_len] = '\0';
                                ZSTR_LEN(tag_str) = tag_len;
-                               ZVAL_NEW_STR(tag, tag_str);
+                               ZEND_TRY_ASSIGN_NEW_STR(tag, tag_str);
                        } else {
                                php_error_docref(NULL, E_WARNING, "Retrieving verification tag failed");
                                zend_string_release_ex(tag_str, 0);
@@ -6700,8 +6697,7 @@ PHP_FUNCTION(openssl_encrypt)
                                RETVAL_FALSE;
                        }
                } else if (tag) {
-                       zval_ptr_dtor(tag);
-                       ZVAL_NULL(tag);
+                       ZEND_TRY_ASSIGN_NULL(tag);
                        php_error_docref(NULL, E_WARNING,
                                        "The authenticated tag cannot be provided for cipher that doesn not support AEAD");
                } else if (mode.is_aead) {
@@ -6848,13 +6844,12 @@ PHP_FUNCTION(openssl_random_pseudo_bytes)
        zend_string *buffer = NULL;
        zval *zstrong_result_returned = NULL;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "l|z/", &buffer_length, &zstrong_result_returned) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "l|z", &buffer_length, &zstrong_result_returned) == FAILURE) {
                return;
        }
 
        if (zstrong_result_returned) {
-               zval_ptr_dtor(zstrong_result_returned);
-               ZVAL_FALSE(zstrong_result_returned);
+               ZEND_TRY_ASSIGN_FALSE(zstrong_result_returned);
        }
 
        if (buffer_length <= 0
@@ -6872,7 +6867,7 @@ PHP_FUNCTION(openssl_random_pseudo_bytes)
        if (php_win32_get_random_bytes((unsigned char*)buffer->val, (size_t) buffer_length) == FAILURE){
                zend_string_release_ex(buffer, 0);
                if (zstrong_result_returned) {
-                       ZVAL_FALSE(zstrong_result_returned);
+                       ZEND_TRY_ASSIGN_FALSE(zstrong_result_returned);
                }
                zend_throw_exception(zend_ce_exception, "Error reading from source device", 0);
                return;
@@ -6885,7 +6880,7 @@ PHP_FUNCTION(openssl_random_pseudo_bytes)
        if (RAND_bytes((unsigned char*)ZSTR_VAL(buffer), (int)buffer_length) <= 0) {
                zend_string_release_ex(buffer, 0);
                if (zstrong_result_returned) {
-                       ZVAL_FALSE(zstrong_result_returned);
+                       ZEND_TRY_ASSIGN_FALSE(zstrong_result_returned);
                }
                zend_throw_exception(zend_ce_exception, "Error reading from source device", 0);
                return;
@@ -6898,7 +6893,7 @@ PHP_FUNCTION(openssl_random_pseudo_bytes)
        RETVAL_NEW_STR(buffer);
 
        if (zstrong_result_returned) {
-               ZVAL_BOOL(zstrong_result_returned, 1);
+               ZEND_TRY_ASSIGN_TRUE(zstrong_result_returned);
        }
 }
 /* }}} */

diff --git a/ext/pcntl/pcntl.c b/ext/pcntl/pcntl.c
index b243b2202749a65111a6a8c4639ede9f5037d93f..cf53edc7f699cb3bd2dc423286e7bf1839d2e5e8 100644 (file)
--- a/ext/pcntl/pcntl.c
+++ b/ext/pcntl/pcntl.c
@@ -663,7 +663,7 @@ PHP_FUNCTION(pcntl_waitpid)
        struct rusage rusage;
 #endif
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "lz/|lz/", &pid, &z_status, &options, &z_rusage) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "lz|lz", &pid, &z_status, &options, &z_rusage) == FAILURE) {
                return;
        }
 
@@ -671,11 +671,9 @@ PHP_FUNCTION(pcntl_waitpid)
 
 #ifdef HAVE_WAIT4
        if (z_rusage) {
-               if (Z_TYPE_P(z_rusage) != IS_ARRAY) {
-                       zval_ptr_dtor(z_rusage);
-                       array_init(z_rusage);
-               } else {
-                       zend_hash_clean(Z_ARRVAL_P(z_rusage));
+               z_rusage = zend_try_array_init(z_rusage);
+               if (!z_rusage) {
+                       return;
                }
 
                memset(&rusage, 0, sizeof(struct rusage));
@@ -697,8 +695,7 @@ PHP_FUNCTION(pcntl_waitpid)
        }
 #endif
 
-       zval_ptr_dtor(z_status);
-       ZVAL_LONG(z_status, status);
+       ZEND_TRY_ASSIGN_LONG(z_status, status);
 
        RETURN_LONG((zend_long) child_id);
 }
@@ -716,18 +713,16 @@ PHP_FUNCTION(pcntl_wait)
        struct rusage rusage;
 #endif
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "z/|lz/", &z_status, &options, &z_rusage) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|lz", &z_status, &options, &z_rusage) == FAILURE) {
                return;
        }
 
        status = zval_get_long(z_status);
 #ifdef HAVE_WAIT3
        if (z_rusage) {
-               if (Z_TYPE_P(z_rusage) != IS_ARRAY) {
-                       zval_ptr_dtor(z_rusage);
-                       array_init(z_rusage);
-               } else {
-                       zend_hash_clean(Z_ARRVAL_P(z_rusage));
+               z_rusage = zend_try_array_init(z_rusage);
+               if (!z_rusage) {
+                       return;
                }
 
                memset(&rusage, 0, sizeof(struct rusage));
@@ -750,8 +745,7 @@ PHP_FUNCTION(pcntl_wait)
        }
 #endif
 
-       zval_ptr_dtor(z_status);
-       ZVAL_LONG(z_status, status);
+       ZEND_TRY_ASSIGN_LONG(z_status, status);
 
        RETURN_LONG((zend_long) child_id);
 }
@@ -1105,7 +1099,7 @@ PHP_FUNCTION(pcntl_sigprocmask)
        zval         *user_set, *user_oldset = NULL, *user_signo;
        sigset_t      set, oldset;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "la|z/", &how, &user_set, &user_oldset) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "la|z", &how, &user_set, &user_oldset) == FAILURE) {
                return;
        }
 
@@ -1131,12 +1125,11 @@ PHP_FUNCTION(pcntl_sigprocmask)
        }
 
        if (user_oldset != NULL) {
-               if (Z_TYPE_P(user_oldset) != IS_ARRAY) {
-                       zval_ptr_dtor(user_oldset);
-                       array_init(user_oldset);
-               } else {
-                       zend_hash_clean(Z_ARRVAL_P(user_oldset));
+               user_oldset = zend_try_array_init(user_oldset);
+               if (!user_oldset) {
+                       return;
                }
+
                for (signo = 1; signo < NSIG; ++signo) {
                        if (sigismember(&oldset, signo) != 1) {
                                continue;
@@ -1162,11 +1155,11 @@ static void pcntl_sigwaitinfo(INTERNAL_FUNCTION_PARAMETERS, int timedwait) /* {{
        struct timespec  timeout;
 
        if (timedwait) {
-               if (zend_parse_parameters(ZEND_NUM_ARGS(), "a|z/ll", &user_set, &user_siginfo, &tv_sec, &tv_nsec) == FAILURE) {
+               if (zend_parse_parameters(ZEND_NUM_ARGS(), "a|zll", &user_set, &user_siginfo, &tv_sec, &tv_nsec) == FAILURE) {
                        return;
                }
        } else {
-               if (zend_parse_parameters(ZEND_NUM_ARGS(), "a|z/", &user_set, &user_siginfo) == FAILURE) {
+               if (zend_parse_parameters(ZEND_NUM_ARGS(), "a|z", &user_set, &user_siginfo) == FAILURE) {
                        return;
                }
        }
@@ -1230,12 +1223,11 @@ PHP_FUNCTION(pcntl_sigtimedwait)
 static void pcntl_siginfo_to_zval(int signo, siginfo_t *siginfo, zval *user_siginfo) /* {{{ */
 {
        if (signo > 0 && user_siginfo) {
-               if (Z_TYPE_P(user_siginfo) != IS_ARRAY) {
-                       zval_ptr_dtor(user_siginfo);
-                       array_init(user_siginfo);
-               } else {
-                       zend_hash_clean(Z_ARRVAL_P(user_siginfo));
+               user_siginfo = zend_try_array_init(user_siginfo);
+               if (!user_siginfo) {
+                       return;
                }
+
                add_assoc_long_ex(user_siginfo, "signo", sizeof("signo")-1, siginfo->si_signo);
                add_assoc_long_ex(user_siginfo, "errno", sizeof("errno")-1, siginfo->si_errno);
                add_assoc_long_ex(user_siginfo, "code",  sizeof("code")-1,  siginfo->si_code);

diff --git a/ext/pcre/php_pcre.c b/ext/pcre/php_pcre.c
index 16ebedd7ac2fb9e20c97fefc1e16914e51871159..8622ea8c6528c4065ccc62e5dddaaa9299ba662d 100644 (file)
--- a/ext/pcre/php_pcre.c
+++ b/ext/pcre/php_pcre.c
@@ -970,7 +970,7 @@ static void php_do_pcre_match(INTERNAL_FUNCTION_PARAMETERS, int global) /* {{{ *
                Z_PARAM_STR(regex)
                Z_PARAM_STR(subject)
                Z_PARAM_OPTIONAL
-               Z_PARAM_ZVAL_DEREF(subpats)
+               Z_PARAM_ZVAL(subpats)
                Z_PARAM_LONG(flags)
                Z_PARAM_LONG(start_offset)
        ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
@@ -1014,8 +1014,10 @@ PHPAPI void php_pcre_match_impl(pcre_cache_entry *pce, char *subject, size_t sub
 
        /* Overwrite the passed-in value for subpatterns with an empty array. */
        if (subpats != NULL) {
-               zval_ptr_dtor(subpats);
-               array_init(subpats);
+               subpats = zend_try_array_init(subpats);
+               if (!subpats) {
+                       return;
+               }
        }
 
        subpats_order = global ? PREG_PATTERN_ORDER : 0;
@@ -2239,7 +2241,7 @@ static void preg_replace_common(INTERNAL_FUNCTION_PARAMETERS, int is_filter)
                Z_PARAM_ZVAL(subject)
                Z_PARAM_OPTIONAL
                Z_PARAM_LONG(limit)
-               Z_PARAM_ZVAL_DEREF(zcount)
+               Z_PARAM_ZVAL(zcount)
        ZEND_PARSE_PARAMETERS_END();
 
        if (Z_TYPE_P(replace) != IS_ARRAY) {
@@ -2305,8 +2307,7 @@ static void preg_replace_common(INTERNAL_FUNCTION_PARAMETERS, int is_filter)
        }
 
        if (zcount) {
-               zval_ptr_dtor(zcount);
-               ZVAL_LONG(zcount, replace_count);
+               ZEND_TRY_ASSIGN_LONG(zcount, replace_count);
        }
 }
 /* }}} */
@@ -2336,7 +2337,7 @@ static PHP_FUNCTION(preg_replace_callback)
                Z_PARAM_ZVAL(subject)
                Z_PARAM_OPTIONAL
                Z_PARAM_LONG(limit)
-               Z_PARAM_ZVAL_DEREF(zcount)
+               Z_PARAM_ZVAL(zcount)
        ZEND_PARSE_PARAMETERS_END();
 
        if (!zend_is_callable_ex(replace, NULL, 0, NULL, &fcc, NULL)) {
@@ -2353,8 +2354,7 @@ static PHP_FUNCTION(preg_replace_callback)
 
        replace_count = preg_replace_func_impl(return_value, regex, &fci, &fcc, subject, limit);
        if (zcount) {
-               zval_ptr_dtor(zcount);
-               ZVAL_LONG(zcount, replace_count);
+               ZEND_TRY_ASSIGN_LONG(zcount, replace_count);
        }
 }
 /* }}} */
@@ -2376,7 +2376,7 @@ static PHP_FUNCTION(preg_replace_callback_array)
                Z_PARAM_ZVAL(subject)
                Z_PARAM_OPTIONAL
                Z_PARAM_LONG(limit)
-               Z_PARAM_ZVAL_DEREF(zcount)
+               Z_PARAM_ZVAL(zcount)
        ZEND_PARSE_PARAMETERS_END();
 
        fci.size = sizeof(fci);
@@ -2421,8 +2421,7 @@ static PHP_FUNCTION(preg_replace_callback_array)
        } ZEND_HASH_FOREACH_END();
 
        if (zcount) {
-               zval_ptr_dtor(zcount);
-               ZVAL_LONG(zcount, replace_count);
+               ZEND_TRY_ASSIGN_LONG(zcount, replace_count);
        }
 }
 /* }}} */

diff --git a/ext/pdo/pdo_stmt.c b/ext/pdo/pdo_stmt.c
index 0b6fc902538a3ab558fd4e54d9f4442b1a487c90..9355d3d3df83f835a8c5b9a4b43ea3937befdcb2 100644 (file)
--- a/ext/pdo/pdo_stmt.c
+++ b/ext/pdo/pdo_stmt.c
@@ -2176,7 +2176,7 @@ const zend_function_entry pdo_dbstmt_functions[] = {
 };
 
 /* {{{ overloaded handlers for PDOStatement class */
-static void dbstmt_prop_write(zval *object, zval *member, zval *value, void **cache_slot)
+static zval *dbstmt_prop_write(zval *object, zval *member, zval *value, void **cache_slot)
 {
        pdo_stmt_t *stmt = Z_PDO_STMT_P(object);
 
@@ -2184,8 +2184,9 @@ static void dbstmt_prop_write(zval *object, zval *member, zval *value, void **ca
 
        if (strcmp(Z_STRVAL_P(member), "queryString") == 0) {
                pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "property queryString is read only");
+               return value;
        } else {
-               zend_std_write_property(object, member, value, cache_slot);
+               return zend_std_write_property(object, member, value, cache_slot);
        }
 }
 
@@ -2499,9 +2500,10 @@ static zval *row_dim_read(zval *object, zval *member, int type, zval *rv)
        return row_prop_read(object, member, type, NULL, rv);
 }
 
-static void row_prop_write(zval *object, zval *member, zval *value, void **cache_slot)
+static zval *row_prop_write(zval *object, zval *member, zval *value, void **cache_slot)
 {
        php_error_docref(NULL, E_WARNING, "This PDORow is not from a writable result set");
+       return value;
 }
 
 static void row_dim_write(zval *object, zval *member, zval *value)

diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c
index 105a87da8b30fa7c254e49955995e4d12076c6cf..323a4d2fa415b6e3061e054d64176086ca15eea7 100644 (file)
--- a/ext/reflection/php_reflection.c
+++ b/ext/reflection/php_reflection.c
@@ -2855,8 +2855,10 @@ ZEND_METHOD(reflection_type, isBuiltin)
 
 /* {{{ reflection_type_name */
 static zend_string *reflection_type_name(type_reference *param) {
-       if (ZEND_TYPE_IS_CLASS(param->type)) {
+       if (ZEND_TYPE_IS_NAME(param->type)) {
                return zend_string_copy(ZEND_TYPE_NAME(param->type));
+       } else if (ZEND_TYPE_IS_CE(param->type)) {
+               return zend_string_copy(ZEND_TYPE_CE(param->type)->name);
        } else {
                char *name = zend_get_type_by_const(ZEND_TYPE_CODE(param->type));
                return zend_string_init(name, strlen(name), 0);
@@ -3809,7 +3811,7 @@ ZEND_METHOD(reflection_class, getStaticPropertyValue)
        if (UNEXPECTED(zend_update_class_constants(ce) != SUCCESS)) {
                return;
        }
-       prop = zend_std_get_static_property(ce, name, 1);
+       prop = zend_std_get_static_property(ce, name, BP_VAR_IS);
        if (!prop) {
                if (def_value) {
                        ZVAL_COPY(return_value, def_value);
@@ -3830,6 +3832,7 @@ ZEND_METHOD(reflection_class, setStaticPropertyValue)
 {
        reflection_object *intern;
        zend_class_entry *ce;
+       zend_property_info *prop_info;
        zend_string *name;
        zval *variable_ptr, *value;
 
@@ -3842,15 +3845,30 @@ ZEND_METHOD(reflection_class, setStaticPropertyValue)
        if (UNEXPECTED(zend_update_class_constants(ce) != SUCCESS)) {
                return;
        }
-       variable_ptr = zend_std_get_static_property(ce, name, 1);
+       variable_ptr = zend_std_get_static_property_with_info(ce, name, BP_VAR_W, &prop_info);
        if (!variable_ptr) {
+               zend_clear_exception();
                zend_throw_exception_ex(reflection_exception_ptr, 0,
                                "Class %s does not have a property named %s", ZSTR_VAL(ce->name), ZSTR_VAL(name));
                return;
        }
-       ZVAL_DEREF(variable_ptr);
+
+       if (Z_ISREF_P(variable_ptr)) {
+               zend_reference *ref = Z_REF_P(variable_ptr);
+               variable_ptr = Z_REFVAL_P(variable_ptr);
+
+               if (!zend_verify_ref_assignable_zval(ref, value, 0)) {
+                       return;
+               }
+       }
+
+       if (prop_info->type && !zend_verify_property_type(prop_info, value, 0)) {
+               return;
+       }
+
        zval_ptr_dtor(variable_ptr);
        ZVAL_COPY(variable_ptr, value);
+
 }
 /* }}} */
 
@@ -5463,6 +5481,55 @@ ZEND_METHOD(reflection_property, setValue)
 }
 /* }}} */
 
+/* {{{ proto public mixed ReflectionProperty::isInitialized([stdclass object])
+   Returns this property's value */
+ZEND_METHOD(reflection_property, isInitialized)
+{
+       reflection_object *intern;
+       property_reference *ref;
+       zval *object, *name;
+       zval *member_p = NULL;
+
+       GET_REFLECTION_OBJECT_PTR(ref);
+
+       if (!(ref->prop.flags & ZEND_ACC_PUBLIC) && intern->ignore_visibility == 0) {
+               name = _default_load_name(getThis());
+               zend_throw_exception_ex(reflection_exception_ptr, 0,
+                       "Cannot access non-public member %s::$%s", ZSTR_VAL(intern->ce->name), Z_STRVAL_P(name));
+               return;
+       }
+
+       if (ref->prop.flags & ZEND_ACC_STATIC) {
+               member_p = zend_read_static_property_ex(intern->ce, ref->unmangled_name, 1);
+               if (member_p) {
+                       RETURN_BOOL(!Z_ISUNDEF_P(member_p))
+               }
+               RETURN_FALSE;
+       } else {
+               zval name_zv;
+               zend_class_entry *old_scope;
+               int retval;
+
+               if (zend_parse_parameters(ZEND_NUM_ARGS(), "o", &object) == FAILURE) {
+                       return;
+               }
+
+               if (!instanceof_function(Z_OBJCE_P(object), ref->prop.ce)) {
+                       _DO_THROW("Given object is not an instance of the class this property was declared in");
+                       /* Returns from this function */
+               }
+
+               old_scope = EG(fake_scope);
+               EG(fake_scope) = intern->ce;
+               ZVAL_STR(&name_zv, ref->unmangled_name);
+               retval = Z_OBJ_HT_P(object)->has_property(object, &name_zv, ZEND_PROPERTY_EXISTS, NULL);
+               EG(fake_scope) = old_scope;
+
+               RETVAL_BOOL(retval);
+       }
+}
+/* }}} */
+
 /* {{{ proto public ReflectionClass ReflectionProperty::getDeclaringClass()
    Get the declaring class */
 ZEND_METHOD(reflection_property, getDeclaringClass)
@@ -5530,6 +5597,44 @@ ZEND_METHOD(reflection_property, setAccessible)
 }
 /* }}} */
 
+/* {{{ proto public ReflectionType ReflectionProperty::getType()
+   Returns the type associated with the property */
+ZEND_METHOD(reflection_property, getType)
+{
+       reflection_object *intern;
+       property_reference *ref;
+
+       if (zend_parse_parameters_none() == FAILURE) {
+               return;
+       }
+
+       GET_REFLECTION_OBJECT_PTR(ref);
+
+       if (!ZEND_TYPE_IS_SET(ref->prop.type)) {
+               RETURN_NULL();
+       }
+
+       reflection_type_factory(ref->prop.type, return_value);
+}
+/* }}} */
+
+/* {{{ proto public bool ReflectionProperty::hasType()
+   Returns whether property has a type */
+ZEND_METHOD(reflection_property, hasType)
+{
+       reflection_object *intern;
+       property_reference *ref;
+
+       if (zend_parse_parameters_none() == FAILURE) {
+               return;
+       }
+
+       GET_REFLECTION_OBJECT_PTR(ref);
+
+       RETVAL_BOOL(ZEND_TYPE_IS_SET(ref->prop.type));
+}
+/* }}} */
+
 /* {{{ proto public static mixed ReflectionExtension::export(string name [, bool return]) throws ReflectionException
    Exports a reflection object. Returns the output if TRUE is specified for return, printing it otherwise. */
 ZEND_METHOD(reflection_extension, export)
@@ -6367,6 +6472,10 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_property_setValue, 0, 0, 1)
        ZEND_ARG_INFO(0, value)
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_property_isInitialized, 0, 0, 0)
+       ZEND_ARG_INFO(0, object)
+ZEND_END_ARG_INFO()
+
 ZEND_BEGIN_ARG_INFO(arginfo_reflection_property_setAccessible, 0)
        ZEND_ARG_INFO(0, visible)
 ZEND_END_ARG_INFO()
@@ -6378,6 +6487,7 @@ static const zend_function_entry reflection_property_functions[] = {
        ZEND_ME(reflection_property, getName, arginfo_reflection__void, 0)
        ZEND_ME(reflection_property, getValue, arginfo_reflection_property_getValue, 0)
        ZEND_ME(reflection_property, setValue, arginfo_reflection_property_setValue, 0)
+       ZEND_ME(reflection_property, isInitialized, arginfo_reflection_property_isInitialized, 0)
        ZEND_ME(reflection_property, isPublic, arginfo_reflection__void, 0)
        ZEND_ME(reflection_property, isPrivate, arginfo_reflection__void, 0)
        ZEND_ME(reflection_property, isProtected, arginfo_reflection__void, 0)
@@ -6387,6 +6497,8 @@ static const zend_function_entry reflection_property_functions[] = {
        ZEND_ME(reflection_property, getDeclaringClass, arginfo_reflection__void, 0)
        ZEND_ME(reflection_property, getDocComment, arginfo_reflection__void, 0)
        ZEND_ME(reflection_property, setAccessible, arginfo_reflection_property_setAccessible, 0)
+       ZEND_ME(reflection_property, getType, arginfo_reflection__void, 0)
+       ZEND_ME(reflection_property, hasType, arginfo_reflection__void, 0)
        PHP_FE_END
 };
 
@@ -6516,7 +6628,7 @@ static const zend_function_entry reflection_ext_functions[] = { /* {{{ */
 }; /* }}} */
 
 /* {{{ _reflection_write_property */
-static void _reflection_write_property(zval *object, zval *member, zval *value, void **cache_slot)
+static zval *_reflection_write_property(zval *object, zval *member, zval *value, void **cache_slot)
 {
        if ((Z_TYPE_P(member) == IS_STRING)
                && zend_hash_exists(&Z_OBJCE_P(object)->properties_info, Z_STR_P(member))
@@ -6525,10 +6637,11 @@ static void _reflection_write_property(zval *object, zval *member, zval *value,
        {
                zend_throw_exception_ex(reflection_exception_ptr, 0,
                        "Cannot set read-only property %s::$%s", ZSTR_VAL(Z_OBJCE_P(object)->name), Z_STRVAL_P(member));
+               return &EG(uninitialized_zval);
        }
        else
        {
-               zend_std_write_property(object, member, value, cache_slot);
+               return zend_std_write_property(object, member, value, cache_slot);
        }
 }
 /* }}} */

diff --git a/ext/reflection/tests/ReflectionClass_setStaticPropertyValue_002.phpt b/ext/reflection/tests/ReflectionClass_setStaticPropertyValue_002.phpt
index 14e8382e410c6f5361571200be9ebd25f58b6eae..fb472681ca4dac4ff734bcb08b1259d5aaf5f915 100644 (file)
--- a/ext/reflection/tests/ReflectionClass_setStaticPropertyValue_002.phpt
+++ b/ext/reflection/tests/ReflectionClass_setStaticPropertyValue_002.phpt
@@ -1,5 +1,5 @@
 --TEST--
-ReflectionClass::getStaticPropertyValue() - bad params
+ReflectionClass::setStaticPropertyValue() - bad params
 --CREDITS--
 Robin Fernandes <robinf@php.net>
 Steve Seear <stevseea@php.net>

diff --git a/ext/reflection/tests/ReflectionClass_setStaticPropertyValue_003.phpt b/ext/reflection/tests/ReflectionClass_setStaticPropertyValue_003.phpt
new file mode 100644 (file)
index 0000000..a83900a
--- /dev/null
+++ b/ext/reflection/tests/ReflectionClass_setStaticPropertyValue_003.phpt
@@ -0,0 +1,39 @@
+--TEST--
+ReflectionClass::setStaticPropertyValue() - type constraints must be enforced
+--FILE--
+<?php
+
+class Test {
+    public static $x;
+    public static int $y = 2;
+}
+
+$rc = new ReflectionClass('Test');
+
+try {
+       $rc->setStaticPropertyValue("y", "foo");
+} catch (TypeError $e) { echo $e->getMessage(), "\n"; }
+var_dump(Test::$y);
+
+$rc->setStaticPropertyValue("y", "21");
+var_dump(Test::$y);
+
+
+Test::$x =& Test::$y;
+
+try {
+       $rc->setStaticPropertyValue("x", "foo");
+} catch (TypeError $e) { echo $e->getMessage(), "\n"; }
+var_dump(Test::$y);
+
+$rc->setStaticPropertyValue("x", "42");
+var_dump(Test::$y);
+
+?>
+--EXPECT--
+Typed property Test::$y must be int, string used
+int(2)
+int(21)
+Cannot assign string to reference held by property Test::$y of type int
+int(21)
+int(42)

diff --git a/ext/reflection/tests/ReflectionProperty_isInitialized.phpt b/ext/reflection/tests/ReflectionProperty_isInitialized.phpt
new file mode 100644 (file)
index 0000000..f1f6e53
--- /dev/null
+++ b/ext/reflection/tests/ReflectionProperty_isInitialized.phpt
@@ -0,0 +1,113 @@
+--TEST--
+Test ReflectionProperty::isInitialized()
+--FILE--
+<?php
+
+class A {
+       public static ?string $ssv = null;
+       public static ?string $ss;
+       public static $s;
+       public ?int $iv = null;
+       public ?int $i;
+       public $n;
+
+    private int $p;
+}
+
+class B extends A { }
+
+echo "Static properties:\n";
+var_dump((new ReflectionProperty(A::class, 'ssv'))->isInitialized());
+var_dump((new ReflectionProperty(A::class, 'ss'))->isInitialized());
+var_dump((new ReflectionProperty(A::class, 's'))->isInitialized());
+
+echo "Declared properties:\n";
+$a = new A;
+var_dump((new ReflectionProperty($a, 'iv'))->isInitialized($a));
+var_dump((new ReflectionProperty($a, 'i'))->isInitialized($a));
+var_dump((new ReflectionProperty($a, 'n'))->isInitialized($a));
+
+echo "Declared properties after unset:\n";
+unset($a->iv);
+unset($a->i);
+unset($a->n);
+var_dump((new ReflectionProperty($a, 'i'))->isInitialized($a));
+var_dump((new ReflectionProperty($a, 'iv'))->isInitialized($a));
+var_dump((new ReflectionProperty($a, 'n'))->isInitialized($a));
+
+echo "Dynamic properties:\n";
+$a->d = null;
+$rp = new ReflectionProperty($a, 'd');
+var_dump($rp->isInitialized($a));
+unset($a->d);
+var_dump($rp->isInitialized($a));
+
+echo "Visibility handling:\n";
+$rp = new ReflectionProperty('A', 'p');
+try {
+    var_dump($rp->isInitialized($a));
+} catch (ReflectionException $e) {
+    echo $e->getMessage(), "\n";
+}
+$rp->setAccessible(true);
+var_dump($rp->isInitialized($a));
+
+echo "Object type:\n";
+$rp = new ReflectionProperty('B', 'i');
+var_dump($rp->isInitialized($a));
+
+try {
+    var_dump($rp->isInitialized(new stdClass));
+} catch (ReflectionException $e) {
+    echo $e->getMessage(), "\n";
+}
+
+class WithMagic {
+    public $prop;
+    public int $intProp;
+
+    public function __isset($name) {
+        echo "__isset($name)\n";
+        return true;
+    }
+
+    public function __get($name) {
+        echo "__get($name)\n";
+        return "foobar";
+    }
+}
+
+echo "Class with __isset:\n";
+$obj = new WithMagic;
+unset($obj->prop);
+$rp = new ReflectionProperty('WithMagic', 'prop');
+var_dump($rp->isInitialized($obj));
+$rp = new ReflectionProperty('WithMagic', 'intProp');
+var_dump($rp->isInitialized($obj));
+
+?>
+--EXPECT--
+Static properties:
+bool(true)
+bool(false)
+bool(true)
+Declared properties:
+bool(true)
+bool(false)
+bool(true)
+Declared properties after unset:
+bool(false)
+bool(false)
+bool(false)
+Dynamic properties:
+bool(true)
+bool(false)
+Visibility handling:
+Cannot access non-public member A::$p
+bool(false)
+Object type:
+bool(false)
+Given object is not an instance of the class this property was declared in
+Class with __isset:
+bool(false)
+bool(false)

diff --git a/ext/reflection/tests/ReflectionProperty_typed_static.phpt b/ext/reflection/tests/ReflectionProperty_typed_static.phpt
new file mode 100644 (file)
index 0000000..77f95d7
--- /dev/null
+++ b/ext/reflection/tests/ReflectionProperty_typed_static.phpt
@@ -0,0 +1,51 @@
+--TEST--
+ReflectionProperty::getValue() on typed static property
+--FILE--
+<?php
+
+class Test {
+    public static int $x = 42;
+    public static int $y;
+    public static $z;
+}
+
+$rp = new ReflectionProperty('Test', 'x');
+var_dump($rp->getValue());
+
+$rp = new ReflectionProperty('Test', 'y');
+try {
+    var_dump($rp->getValue());
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+
+$rp->setValue("24");
+var_dump($rp->getValue());
+
+try {
+    $rp->setValue("foo");
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+var_dump($rp->getValue());
+
+Test::$z =& Test::$y;
+
+$rp = new ReflectionProperty('Test', 'z');
+try {
+    $rp->setValue("foo");
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+var_dump($rp->getValue());
+
+
+?>
+--EXPECT--
+int(42)
+Typed static property Test::$y must not be accessed before initialization
+int(24)
+Typed property Test::$y must be int, string used
+int(24)
+Cannot assign string to reference held by property Test::$y of type int
+int(24)

diff --git a/ext/reflection/tests/ReflectionType_001.phpt b/ext/reflection/tests/ReflectionType_001.phpt
index d949e18107e7ad27bdd6aff85670bf9f8ef4b5da..e47a9615ba56f4cdb4d2e98c44e9526f7dafdef5 100644 (file)
--- a/ext/reflection/tests/ReflectionType_001.phpt
+++ b/ext/reflection/tests/ReflectionType_001.phpt
@@ -74,6 +74,32 @@ foreach ([
   }
 }
 
+echo "\n*** property types\n";
+
+class PropTypeTest {
+       public int $int;
+       public string $string;
+       public array $arr;
+       public iterable $iterable;
+       public stdClass $std;
+       public OtherThing $other;
+       public $mixed;
+}
+
+$reflector = new ReflectionClass(PropTypeTest::class);
+
+foreach ($reflector->getProperties() as $name => $property) {
+       if ($property->hasType()) {
+               printf("public %s $%s;\n",
+                       $property->getType(), $property->getName());
+       } else printf("public $%s;\n", $property->getName());
+}
+
+echo "*** resolved property types\n";
+$obj = new PropTypeTest;
+$obj->std = new stdClass;
+$r = (new ReflectionProperty($obj, 'std'))->getType();
+var_dump($r->getName());
 ?>
 --EXPECT--
 *** functions
@@ -185,3 +211,14 @@ bool(true)
 bool(false)
 bool(false)
 string(4) "Test"
+
+*** property types
+public int $int;
+public string $string;
+public array $arr;
+public iterable $iterable;
+public stdClass $std;
+public OtherThing $other;
+public $mixed;
+*** resolved property types
+string(8) "stdClass"

diff --git a/ext/simplexml/simplexml.c b/ext/simplexml/simplexml.c
index 15618244ffb9b2a896198b6e30a764b991dd6310..49f2a8a7e643fefa6cab12d0aad229c02619a1b3 100644 (file)
--- a/ext/simplexml/simplexml.c
+++ b/ext/simplexml/simplexml.c
@@ -415,7 +415,7 @@ static void change_node_zval(xmlNodePtr node, zval *value)
 
 /* {{{ sxe_property_write()
  */
-static int sxe_prop_dim_write(zval *object, zval *member, zval *value, zend_bool elements, zend_bool attribs, xmlNodePtr *pnewnode)
+static zval *sxe_prop_dim_write(zval *object, zval *member, zval *value, zend_bool elements, zend_bool attribs, xmlNodePtr *pnewnode)
 {
        php_sxe_object *sxe;
        xmlNodePtr      node;
@@ -429,7 +429,6 @@ static int sxe_prop_dim_write(zval *object, zval *member, zval *value, zend_bool
        int             test = 0;
        int                             new_value = 0;
        zend_long            cnt = 0;
-       int                             retval = SUCCESS;
        zval            tmp_zv, zval_copy;
        zend_string    *trim_str;
 
@@ -442,7 +441,7 @@ static int sxe_prop_dim_write(zval *object, zval *member, zval *value, zend_bool
                         * and this is during runtime.
                         */
                        zend_throw_error(NULL, "Cannot create unnamed attribute");
-                       return FAILURE;
+                       return &EG(error_zval);
                }
                goto long_dim;
        } else {
@@ -466,7 +465,7 @@ long_dim:
                                if (member == &tmp_zv) {
                                        zval_ptr_dtor_str(&tmp_zv);
                                }
-                               return FAILURE;
+                               return &EG(error_zval);
                        }
                }
        }
@@ -491,7 +490,7 @@ long_dim:
                         * and this is during runtime.
                         */
                        zend_throw_error(NULL, "Cannot create unnamed attribute");
-                       return FAILURE;
+                       return &EG(error_zval);
                }
                if (attribs && !node && sxe->iter.type == SXE_ITER_ELEMENT) {
                        node = xmlNewChild(mynode, mynode->ns, sxe->iter.name, NULL);
@@ -528,7 +527,7 @@ long_dim:
                                        zval_ptr_dtor_str(&tmp_zv);
                                }
                                zend_error(E_WARNING, "It is not yet possible to assign complex types to %s", attribs ? "attributes" : "properties");
-                               return FAILURE;
+                               return &EG(error_zval);
                }
        }
 
@@ -566,7 +565,7 @@ long_dim:
                                        if (new_value) {
                                                zval_ptr_dtor(value);
                                        }
-                                       return FAILURE;
+                                       return &EG(error_zval);
                                }
 
                                if (sxe->iter.type == SXE_ITER_NONE) {
@@ -574,7 +573,7 @@ long_dim:
                                        ++counter;
                                        if (member && Z_LVAL_P(member) > 0) {
                                                php_error_docref(NULL, E_WARNING, "Cannot add element %s number " ZEND_LONG_FMT " when only 0 such elements exist", mynode->name, Z_LVAL_P(member));
-                                               retval = FAILURE;
+                                               value = &EG(error_zval);
                                        }
                                } else if (member) {
                                        newnode = sxe_get_element_by_offset(sxe, Z_LVAL_P(member), node, &cnt);
@@ -611,7 +610,7 @@ next_iter:
                        }
                } else if (counter > 1) {
                        php_error_docref(NULL, E_WARNING, "Cannot assign to an array of nodes (duplicate subnodes or attr detected)");
-                       retval = FAILURE;
+                       value = &EG(error_zval);
                } else if (elements) {
                        if (!node) {
                                if (!member || Z_TYPE_P(member) == IS_LONG) {
@@ -622,14 +621,12 @@ next_iter:
                        } else if (!member || Z_TYPE_P(member) == IS_LONG) {
                                if (member && cnt < Z_LVAL_P(member)) {
                                        php_error_docref(NULL, E_WARNING, "Cannot add element %s number " ZEND_LONG_FMT " when only " ZEND_LONG_FMT " such elements exist", mynode->name, Z_LVAL_P(member), cnt);
-                                       retval = FAILURE;
                                }
                                newnode = xmlNewTextChild(mynode->parent, mynode->ns, mynode->name, value ? (xmlChar *)Z_STRVAL_P(value) : NULL);
                        }
                } else if (attribs) {
                        if (Z_TYPE_P(member) == IS_LONG) {
                                php_error_docref(NULL, E_WARNING, "Cannot change attribute number " ZEND_LONG_FMT " when only %d attributes exist", Z_LVAL_P(member), nodendx);
-                               retval = FAILURE;
                        } else {
                                newnode = (xmlNodePtr)xmlNewProp(node, (xmlChar *)Z_STRVAL_P(member), value ? (xmlChar *)Z_STRVAL_P(value) : NULL);
                        }
@@ -645,15 +642,17 @@ next_iter:
        if (new_value) {
                zval_ptr_dtor(value);
        }
-       return retval;
+       return value;
 }
 /* }}} */
 
 /* {{{ sxe_property_write()
  */
-static void sxe_property_write(zval *object, zval *member, zval *value, void **cache_slot)
+static zval *sxe_property_write(zval *object, zval *member, zval *value, void **cache_slot)
 {
-       sxe_prop_dim_write(object, member, value, 1, 0, NULL);
+       zval *retval = sxe_prop_dim_write(object, member, value, 1, 0, NULL);
+
+       return retval == &EG(error_zval) ? &EG(uninitialized_zval) : retval;
 }
 /* }}} */
 
@@ -682,7 +681,7 @@ static zval *sxe_property_get_adr(zval *object, zval *member, int fetch_type, vo
        if (node) {
                return NULL;
        }
-       if (sxe_prop_dim_write(object, member, NULL, 1, 0, &node) != SUCCESS) {
+       if (sxe_prop_dim_write(object, member, NULL, 1, 0, &node) == &EG(error_zval)) {
                return NULL;
        }
        type = SXE_ITER_NONE;

diff --git a/ext/snmp/snmp.c b/ext/snmp/snmp.c
index 7ee8ce416a08c2f46ba08e6792cd5f593b6c2e8c..375d1556ad45aa00828e41de2d24b66c420c5a56 100644 (file)
--- a/ext/snmp/snmp.c
+++ b/ext/snmp/snmp.c
@@ -1949,7 +1949,7 @@ zval *php_snmp_read_property(zval *object, zval *member, int type, void **cache_
 
 /* {{{ php_snmp_write_property(zval *object, zval *member, zval *value[, const zend_literal *key])
    Generic object property writer */
-void php_snmp_write_property(zval *object, zval *member, zval *value, void **cache_slot)
+zval *php_snmp_write_property(zval *object, zval *member, zval *value, void **cache_slot)
 {
        zval tmp_member;
        php_snmp_object *obj;
@@ -1973,12 +1973,14 @@ void php_snmp_write_property(zval *object, zval *member, zval *value, void **cac
                }
                */
        } else {
-               zend_std_write_property(object, member, value, cache_slot);
+               value = zend_std_write_property(object, member, value, cache_slot);
        }
 
        if (member == &tmp_member) {
                zval_ptr_dtor(member);
        }
+
+       return value;
 }
 /* }}} */
 

diff --git a/ext/soap/soap.c b/ext/soap/soap.c
index c661dbd793933fd12f815689973ca2ee2ac7fbd5..4888309d2886c120924a0d306e71c420f3092910 100644 (file)
--- a/ext/soap/soap.c
+++ b/ext/soap/soap.c
@@ -2800,7 +2800,7 @@ static void verify_soap_headers_array(HashTable *ht) /* {{{ */
 }
 /* }}} */
 
-/* {{{ proto mixed SoapClient::__call(string function_name, array arguments [, array options [, array input_headers [, array output_headers]]])
+/* {{{ proto mixed SoapClient::__call(string function_name, array arguments [, array options [, array input_headers [, array &output_headers]]])
    Calls a SOAP function */
 PHP_METHOD(SoapClient, __call)
 {
@@ -2819,7 +2819,7 @@ PHP_METHOD(SoapClient, __call)
        zend_bool free_soap_headers = 0;
        zval *this_ptr;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "sa|a!zz/",
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "sa|a!zz",
                &function, &function_len, &args, &options, &headers, &output_headers) == FAILURE) {
                return;
        }
@@ -2891,14 +2891,18 @@ PHP_METHOD(SoapClient, __call)
                } ZEND_HASH_FOREACH_END();
        }
        if (output_headers) {
-               zval_ptr_dtor(output_headers);
-               array_init(output_headers);
+               output_headers = zend_try_array_init(output_headers);
+               if (!output_headers) {
+                       goto cleanup;
+               }
        }
+
        do_soap_call(execute_data, this_ptr, function, function_len, arg_count, real_args, return_value, location, soap_action, uri, soap_headers, output_headers);
+
+cleanup:
        if (arg_count > 0) {
                efree(real_args);
        }
-
        if (soap_headers && free_soap_headers) {
                zend_hash_destroy(soap_headers);
                efree(soap_headers);

diff --git a/ext/sockets/sockets.c b/ext/sockets/sockets.c
index 1f3a4cd4c7ec2efa37ceae229fb5ae8de4a33fbc..f80075d3d5e5ca1f4eac3c019ae008d11a4bc50e 100644 (file)
--- a/ext/sockets/sockets.c
+++ b/ext/sockets/sockets.c
@@ -1313,7 +1313,7 @@ PHP_FUNCTION(socket_getsockname)
        char                                    *addr_string;
        socklen_t                               salen = sizeof(php_sockaddr_storage);
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rz/|z/", &arg1, &addr, &port) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rz|z", &arg1, &addr, &port) == FAILURE) {
                return;
        }
 
@@ -1337,12 +1337,10 @@ PHP_FUNCTION(socket_getsockname)
                case AF_INET6:
                        sin6 = (struct sockaddr_in6 *) sa;
                        inet_ntop(AF_INET6, &sin6->sin6_addr, addr6, INET6_ADDRSTRLEN);
-                       zval_ptr_dtor(addr);
-                       ZVAL_STRING(addr, addr6);
+                       ZEND_TRY_ASSIGN_STRING(addr, addr6);
 
                        if (port != NULL) {
-                               zval_ptr_dtor(port);
-                               ZVAL_LONG(port, htons(sin6->sin6_port));
+                               ZEND_TRY_ASSIGN_LONG(port, htons(sin6->sin6_port));
                        }
                        RETURN_TRUE;
                        break;
@@ -1354,12 +1352,10 @@ PHP_FUNCTION(socket_getsockname)
                        addr_string = inet_ntoa(sin->sin_addr);
                        inet_ntoa_lock = 0;
 
-                       zval_ptr_dtor(addr);
-                       ZVAL_STRING(addr, addr_string);
+                       ZEND_TRY_ASSIGN_STRING(addr, addr_string);
 
                        if (port != NULL) {
-                               zval_ptr_dtor(port);
-                               ZVAL_LONG(port, htons(sin->sin_port));
+                               ZEND_TRY_ASSIGN_LONG(port, htons(sin->sin_port));
                        }
                        RETURN_TRUE;
                        break;
@@ -1367,8 +1363,7 @@ PHP_FUNCTION(socket_getsockname)
                case AF_UNIX:
                        s_un = (struct sockaddr_un *) sa;
 
-                       zval_ptr_dtor(addr);
-                       ZVAL_STRING(addr, s_un->sun_path);
+                       ZEND_TRY_ASSIGN_STRING(addr, s_un->sun_path);
                        RETURN_TRUE;
                        break;
 
@@ -1396,7 +1391,7 @@ PHP_FUNCTION(socket_getpeername)
        char                                    *addr_string;
        socklen_t                               salen = sizeof(php_sockaddr_storage);
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rz/|z/", &arg1, &arg2, &arg3) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rz|z", &arg1, &arg2, &arg3) == FAILURE) {
                return;
        }
 
@@ -1416,12 +1411,11 @@ PHP_FUNCTION(socket_getpeername)
                case AF_INET6:
                        sin6 = (struct sockaddr_in6 *) sa;
                        inet_ntop(AF_INET6, &sin6->sin6_addr, addr6, INET6_ADDRSTRLEN);
-                       zval_ptr_dtor(arg2);
-                       ZVAL_STRING(arg2, addr6);
+
+                       ZEND_TRY_ASSIGN_STRING(arg2, addr6);
 
                        if (arg3 != NULL) {
-                               zval_ptr_dtor(arg3);
-                               ZVAL_LONG(arg3, htons(sin6->sin6_port));
+                               ZEND_TRY_ASSIGN_LONG(arg3, htons(sin6->sin6_port));
                        }
 
                        RETURN_TRUE;
@@ -1434,12 +1428,10 @@ PHP_FUNCTION(socket_getpeername)
                        addr_string = inet_ntoa(sin->sin_addr);
                        inet_ntoa_lock = 0;
 
-                       zval_ptr_dtor(arg2);
-                       ZVAL_STRING(arg2, addr_string);
+                       ZEND_TRY_ASSIGN_STRING(arg2, addr_string);
 
                        if (arg3 != NULL) {
-                               zval_ptr_dtor(arg3);
-                               ZVAL_LONG(arg3, htons(sin->sin_port));
+                               ZEND_TRY_ASSIGN_LONG(arg3, htons(sin->sin_port));
                        }
 
                        RETURN_TRUE;
@@ -1448,8 +1440,7 @@ PHP_FUNCTION(socket_getpeername)
                case AF_UNIX:
                        s_un = (struct sockaddr_un *) sa;
 
-                       zval_ptr_dtor(arg2);
-                       ZVAL_STRING(arg2, s_un->sun_path);
+                       ZEND_TRY_ASSIGN_STRING(arg2, s_un->sun_path);
                        RETURN_TRUE;
                        break;
 
@@ -1703,7 +1694,7 @@ PHP_FUNCTION(socket_recv)
        int                     retval;
        zend_long               len, flags;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rz/ll", &php_sock_res, &buf, &len, &flags) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rzll", &php_sock_res, &buf, &len, &flags) == FAILURE) {
                return;
        }
 
@@ -1720,16 +1711,11 @@ PHP_FUNCTION(socket_recv)
 
        if ((retval = recv(php_sock->bsd_socket, ZSTR_VAL(recv_buf), len, flags)) < 1) {
                zend_string_efree(recv_buf);
-
-               zval_ptr_dtor(buf);
-               ZVAL_NULL(buf);
+               ZEND_TRY_ASSIGN_NULL(buf);
        } else {
                ZSTR_LEN(recv_buf) = retval;
                ZSTR_VAL(recv_buf)[ZSTR_LEN(recv_buf)] = '\0';
-
-               /* Rebuild buffer zval */
-               zval_ptr_dtor(buf);
-               ZVAL_NEW_STR(buf, recv_buf);
+               ZEND_TRY_ASSIGN_NEW_STR(buf, recv_buf);
        }
 
        if (retval == -1) {
@@ -1793,7 +1779,7 @@ PHP_FUNCTION(socket_recvfrom)
        char                            *address;
        zend_string                     *recv_buf;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rz/llz/|z/", &arg1, &arg2, &arg3, &arg4, &arg5, &arg6) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rzllz|z", &arg1, &arg2, &arg3, &arg4, &arg5, &arg6) == FAILURE) {
                return;
        }
 
@@ -1824,11 +1810,8 @@ PHP_FUNCTION(socket_recvfrom)
                        ZSTR_LEN(recv_buf) = retval;
                        ZSTR_VAL(recv_buf)[ZSTR_LEN(recv_buf)] = '\0';
 
-                       zval_ptr_dtor(arg2);
-                       zval_ptr_dtor(arg5);
-
-                       ZVAL_NEW_STR(arg2, recv_buf);
-                       ZVAL_STRING(arg5, s_un.sun_path);
+                       ZEND_TRY_ASSIGN_NEW_STR(arg2, recv_buf);
+                       ZEND_TRY_ASSIGN_STRING(arg5, s_un.sun_path);
                        break;
 
                case AF_INET:
@@ -1851,15 +1834,11 @@ PHP_FUNCTION(socket_recvfrom)
                        ZSTR_LEN(recv_buf) = retval;
                        ZSTR_VAL(recv_buf)[ZSTR_LEN(recv_buf)] = '\0';
 
-                       zval_ptr_dtor(arg2);
-                       zval_ptr_dtor(arg5);
-                       zval_ptr_dtor(arg6);
-
                        address = inet_ntoa(sin.sin_addr);
 
-                       ZVAL_NEW_STR(arg2, recv_buf);
-                       ZVAL_STRING(arg5, address ? address : "0.0.0.0");
-                       ZVAL_LONG(arg6, ntohs(sin.sin_port));
+                       ZEND_TRY_ASSIGN_NEW_STR(arg2, recv_buf);
+                       ZEND_TRY_ASSIGN_STRING(arg5, address ? address : "0.0.0.0");
+                       ZEND_TRY_ASSIGN_LONG(arg6, ntohs(sin.sin_port));
                        break;
 #if HAVE_IPV6
                case AF_INET6:
@@ -1882,16 +1861,12 @@ PHP_FUNCTION(socket_recvfrom)
                        ZSTR_LEN(recv_buf) = retval;
                        ZSTR_VAL(recv_buf)[ZSTR_LEN(recv_buf)] = '\0';
 
-                       zval_ptr_dtor(arg2);
-                       zval_ptr_dtor(arg5);
-                       zval_ptr_dtor(arg6);
-
                        memset(addr6, 0, INET6_ADDRSTRLEN);
                        inet_ntop(AF_INET6, &sin6.sin6_addr, addr6, INET6_ADDRSTRLEN);
 
-                       ZVAL_NEW_STR(arg2, recv_buf);
-                       ZVAL_STRING(arg5, addr6[0] ? addr6 : "::");
-                       ZVAL_LONG(arg6, ntohs(sin6.sin6_port));
+                       ZEND_TRY_ASSIGN_NEW_STR(arg2, recv_buf);
+                       ZEND_TRY_ASSIGN_STRING(arg5, addr6[0] ? addr6 : "::");
+                       ZEND_TRY_ASSIGN_LONG(arg6, ntohs(sin6.sin6_port));
                        break;
 #endif
                default:
@@ -2253,7 +2228,7 @@ PHP_FUNCTION(socket_create_pair)
        PHP_SOCKET      fds_array[2];
        zend_long               domain, type, protocol;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "lllz/", &domain, &type, &protocol, &fds_array_zval) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "lllz", &domain, &type, &protocol, &fds_array_zval) == FAILURE) {
                return;
        }
 
@@ -2282,8 +2257,12 @@ PHP_FUNCTION(socket_create_pair)
                RETURN_FALSE;
        }
 
-       zval_ptr_dtor(fds_array_zval);
-       array_init(fds_array_zval);
+       fds_array_zval = zend_try_array_init(fds_array_zval);
+       if (!fds_array_zval) {
+               efree(php_sock[0]);
+               efree(php_sock[1]);
+               return;
+       }
 
        php_sock[0]->bsd_socket = fds_array[0];
        php_sock[1]->bsd_socket = fds_array[1];

diff --git a/ext/spl/spl_array.c b/ext/spl/spl_array.c
index 91dec7c09eca257c43479e86fb8d8b3c02eecafb..748263984abf7f37cbb300d0e172ac273d060a80 100644 (file)
--- a/ext/spl/spl_array.c
+++ b/ext/spl/spl_array.c
@@ -878,16 +878,16 @@ static zval *spl_array_read_property(zval *object, zval *member, int type, void
        return zend_std_read_property(object, member, type, cache_slot, rv);
 } /* }}} */
 
-static void spl_array_write_property(zval *object, zval *member, zval *value, void **cache_slot) /* {{{ */
+static zval *spl_array_write_property(zval *object, zval *member, zval *value, void **cache_slot) /* {{{ */
 {
        spl_array_object *intern = Z_SPLARRAY_P(object);
 
        if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0
        && !zend_std_has_property(object, member, ZEND_PROPERTY_EXISTS, NULL)) {
                spl_array_write_dimension(object, member, value);
-               return;
+               return value;
        }
-       zend_std_write_property(object, member, value, cache_slot);
+       return zend_std_write_property(object, member, value, cache_slot);
 } /* }}} */
 
 static zval *spl_array_get_property_ptr_ptr(zval *object, zval *member, int type, void **cache_slot) /* {{{ */

diff --git a/ext/spl/tests/iterator_035.phpt b/ext/spl/tests/iterator_035.phpt
index e6d68fbea671aa8e7c379c77904f2c58b11f2f66..06886354503670e8400e4eae3f60dba06c4a18f3 100644 (file)
--- a/ext/spl/tests/iterator_035.phpt
+++ b/ext/spl/tests/iterator_035.phpt
@@ -14,7 +14,7 @@ echo "Done\n";
 --EXPECTF--
 Notice: Indirect modification of overloaded element of ArrayIterator has no effect in %s on line %d
 
-Fatal error: Uncaught Error: Cannot assign by reference to overloaded object in %s:%d
+Fatal error: Uncaught Error: Cannot assign by reference to an array dimension of an object in %s:%d
 Stack trace:
 #0 {main}
   thrown in %s on line %d

diff --git a/ext/standard/array.c b/ext/standard/array.c
index 33ea028602ec213b20e89ddee03ed9b510002ad7..8088c0da8af41092687bd117af6295d726314ed4 100644 (file)
--- a/ext/standard/array.c
+++ b/ext/standard/array.c
@@ -1786,9 +1786,11 @@ static zend_long php_extract_if_exists(zend_array *arr, zend_array *symbol_table
                                zend_throw_error(NULL, "Cannot re-assign $this");
                                return -1;
                        }
-                       ZVAL_DEREF(orig_var);
-                       zval_ptr_dtor(orig_var);
-                       ZVAL_COPY_DEREF(orig_var, entry);
+                       ZVAL_DEREF(entry);
+                       ZEND_TRY_ASSIGN_COPY_EX(orig_var, entry, 0);
+                       if (UNEXPECTED(EG(exception))) {
+                               return -1;
+                       }
                        count++;
                }
        } ZEND_HASH_FOREACH_END();
@@ -1869,9 +1871,11 @@ static zend_long php_extract_overwrite(zend_array *arr, zend_array *symbol_table
                        if (zend_string_equals_literal(var_name, "GLOBALS")) {
                                continue;
                        }
-                       ZVAL_DEREF(orig_var);
-                       zval_ptr_dtor(orig_var);
-                       ZVAL_COPY_DEREF(orig_var, entry);
+                       ZVAL_DEREF(entry);
+                       ZEND_TRY_ASSIGN_COPY_EX(orig_var, entry, 0);
+                       if (UNEXPECTED(EG(exception))) {
+                               return -1;
+                       }
                } else {
                        ZVAL_DEREF(entry);
                        Z_TRY_ADDREF_P(entry);
@@ -1971,9 +1975,11 @@ static zend_long php_extract_prefix_if_exists(zend_array *arr, zend_array *symbo
                                                if (Z_TYPE_P(orig_var) == IS_INDIRECT) {
                                                        orig_var = Z_INDIRECT_P(orig_var);
                                                }
-                                               ZVAL_DEREF(orig_var);
-                                               zval_ptr_dtor(orig_var);
-                                               ZVAL_COPY(orig_var, entry);
+                                               ZEND_TRY_ASSIGN_COPY_EX(orig_var, entry, 0);
+                                               if (UNEXPECTED(EG(exception))) {
+                                                       zend_string_release_ex(Z_STR(final_name), 0);
+                                                       return -1;
+                                               }
                                        } else {
                                                Z_TRY_ADDREF_P(entry);
                                                zend_hash_add_new(symbol_table, Z_STR(final_name), entry);
@@ -2097,9 +2103,11 @@ static zend_long php_extract_prefix_same(zend_array *arr, zend_array *symbol_tab
                                                if (Z_TYPE_P(orig_var) == IS_INDIRECT) {
                                                        orig_var = Z_INDIRECT_P(orig_var);
                                                }
-                                               ZVAL_DEREF(orig_var);
-                                               zval_ptr_dtor(orig_var);
-                                               ZVAL_COPY(orig_var, entry);
+                                               ZEND_TRY_ASSIGN_COPY_EX(orig_var, entry, 0);
+                                               if (UNEXPECTED(EG(exception))) {
+                                                       zend_string_release_ex(Z_STR(final_name), 0);
+                                                       return -1;
+                                               }
                                        } else {
                                                Z_TRY_ADDREF_P(entry);
                                                zend_hash_add_new(symbol_table, Z_STR(final_name), entry);
@@ -2202,9 +2210,11 @@ static zend_long php_extract_prefix_all(zend_array *arr, zend_array *symbol_tabl
                                        if (Z_TYPE_P(orig_var) == IS_INDIRECT) {
                                                orig_var = Z_INDIRECT_P(orig_var);
                                        }
-                                       ZVAL_DEREF(orig_var);
-                                       zval_ptr_dtor(orig_var);
-                                       ZVAL_COPY(orig_var, entry);
+                                       ZEND_TRY_ASSIGN_COPY_EX(orig_var, entry, 0);
+                                       if (UNEXPECTED(EG(exception))) {
+                                               zend_string_release_ex(Z_STR(final_name), 0);
+                                               return -1;
+                                       }
                                } else {
                                        Z_TRY_ADDREF_P(entry);
                                        zend_hash_add_new(symbol_table, Z_STR(final_name), entry);
@@ -2309,9 +2319,11 @@ static zend_long php_extract_prefix_invalid(zend_array *arr, zend_array *symbol_
                                if (Z_TYPE_P(orig_var) == IS_INDIRECT) {
                                        orig_var = Z_INDIRECT_P(orig_var);
                                }
-                               ZVAL_DEREF(orig_var);
-                               zval_ptr_dtor(orig_var);
-                               ZVAL_COPY(orig_var, entry);
+                               ZEND_TRY_ASSIGN_COPY_EX(orig_var, entry, 0);
+                               if (UNEXPECTED(EG(exception))) {
+                                       zend_string_release_ex(Z_STR(final_name), 0);
+                                       return -1;
+                               }
                        } else {
                                Z_TRY_ADDREF_P(entry);
                                zend_hash_add_new(symbol_table, Z_STR(final_name), entry);

diff --git a/ext/standard/basic_functions.c b/ext/standard/basic_functions.c
index 9026cacc7967eca6583a734194790e506637ae7f..38949a6080028206d8d5dfab1cf298b65d91d5f4 100644 (file)
--- a/ext/standard/basic_functions.c
+++ b/ext/standard/basic_functions.c
@@ -4376,13 +4376,12 @@ PHP_FUNCTION(getopt)
                Z_PARAM_STRING(options, options_len)
                Z_PARAM_OPTIONAL
                Z_PARAM_ARRAY(p_longopts)
-               Z_PARAM_ZVAL_DEREF(zoptind)
+               Z_PARAM_ZVAL(zoptind)
        ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
        /* Init zoptind to 1 */
        if (zoptind) {
-               zval_ptr_dtor(zoptind);
-               ZVAL_LONG(zoptind, 1);
+               ZEND_TRY_ASSIGN_LONG(zoptind, 1);
        }
 
        /* Get argv from the global symbol table. We calculate argc ourselves
@@ -4530,7 +4529,7 @@ PHP_FUNCTION(getopt)
 
        /* Set zoptind to php_optind */
        if (zoptind) {
-               ZVAL_LONG(zoptind, php_optind);
+               ZEND_TRY_ASSIGN_LONG(zoptind, php_optind);
        }
 
        free_longopts(orig_opts);

diff --git a/ext/standard/dns.c b/ext/standard/dns.c
index 50f81153a5b0910d1f1179a3da7eb0dfee0b3d58..15005dce0ef8f1b1884a1fdf334514f7ea7d50e7 100644 (file)
--- a/ext/standard/dns.c
+++ b/ext/standard/dns.c
@@ -816,18 +816,22 @@ PHP_FUNCTION(dns_get_record)
                Z_PARAM_STRING(hostname, hostname_len)
                Z_PARAM_OPTIONAL
                Z_PARAM_LONG(type_param)
-               Z_PARAM_ZVAL_DEREF_EX(authns, 1, 0)
-               Z_PARAM_ZVAL_DEREF_EX(addtl, 1, 0)
+               Z_PARAM_ZVAL(authns)
+               Z_PARAM_ZVAL(addtl)
                Z_PARAM_BOOL(raw)
        ZEND_PARSE_PARAMETERS_END();
 
        if (authns) {
-               zval_ptr_dtor(authns);
-               array_init(authns);
+               authns = zend_try_array_init(authns);
+               if (!authns) {
+                       return;
+               }
        }
        if (addtl) {
-               zval_ptr_dtor(addtl);
-               array_init(addtl);
+               addtl = zend_try_array_init(addtl);
+               if (!addtl) {
+                       return;
+               }
        }
 
        if (!raw) {
@@ -1049,17 +1053,21 @@ PHP_FUNCTION(dns_get_mx)
 
        ZEND_PARSE_PARAMETERS_START(2, 3)
                Z_PARAM_STRING(hostname, hostname_len)
-               Z_PARAM_ZVAL_DEREF(mx_list)
+               Z_PARAM_ZVAL(mx_list)
                Z_PARAM_OPTIONAL
-               Z_PARAM_ZVAL_DEREF(weight_list)
+               Z_PARAM_ZVAL(weight_list)
        ZEND_PARSE_PARAMETERS_END();
 
-       zval_ptr_dtor(mx_list);
-       array_init(mx_list);
+       mx_list = zend_try_array_init(mx_list);
+       if (!mx_list) {
+               return;
+       }
 
        if (weight_list) {
-               zval_ptr_dtor(weight_list);
-               array_init(weight_list);
+               weight_list = zend_try_array_init(weight_list);
+               if (!weight_list) {
+                       return;
+               }
        }
 
 #if defined(HAVE_DNS_SEARCH)

diff --git a/ext/standard/dns_win32.c b/ext/standard/dns_win32.c
index aa11a01f478c50f36e9b04cc7324e61bb6e655b2..393b41d0e822b236e81bc56e7b29d95bad82165c 100644 (file)
--- a/ext/standard/dns_win32.c
+++ b/ext/standard/dns_win32.c
@@ -50,7 +50,7 @@ PHP_FUNCTION(dns_get_mx) /* {{{ */
        DNS_STATUS      status;                 /* Return value of DnsQuery_A() function */
        PDNS_RECORD     pResult, pRec;          /* Pointer to DNS_RECORD structure */
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz/|z/", &hostname, &hostname_len, &mx_list, &weight_list) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz|z", &hostname, &hostname_len, &mx_list, &weight_list) == FAILURE) {
                return;
        }
 
@@ -60,12 +60,16 @@ PHP_FUNCTION(dns_get_mx) /* {{{ */
                RETURN_FALSE;
        }
 
-       zval_ptr_dtor(mx_list);
-       array_init(mx_list);
+       mx_list = zend_try_array_init(mx_list);
+       if (!mx_list) {
+               goto cleanup;
+       }
 
        if (weight_list) {
-               zval_ptr_dtor(weight_list);
-               array_init(weight_list);
+               weight_list = zend_try_array_init(weight_list);
+               if (!weight_list) {
+                       goto cleanup;
+               }
        }
 
        for (pRec = pResult; pRec; pRec = pRec->pNext) {
@@ -81,6 +85,7 @@ PHP_FUNCTION(dns_get_mx) /* {{{ */
                }
        }
 
+cleanup:
        /* Free memory allocated for DNS records. */
        DnsRecordListFree(pResult, DnsFreeRecordListDeep);
 
@@ -352,18 +357,22 @@ PHP_FUNCTION(dns_get_record)
        int type, type_to_fetch, first_query = 1, store_results = 1;
        zend_bool raw = 0;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|lz/!z/!b",
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|lz!z!b",
                        &hostname, &hostname_len, &type_param, &authns, &addtl, &raw) == FAILURE) {
                return;
        }
 
        if (authns) {
-               zval_ptr_dtor(authns);
-               array_init(authns);
+               authns = zend_try_array_init(authns);
+               if (!authns) {
+                       return;
+               }
        }
        if (addtl) {
-               zval_ptr_dtor(addtl);
-               array_init(addtl);
+               addtl = zend_try_array_init(addtl);
+               if (!addtl) {
+                       return;
+               }
        }
 
        if (!raw) {

diff --git a/ext/standard/exec.c b/ext/standard/exec.c
index 5b885c554d8cd5bcd25cd1c06d2caa52521c82ce..bfad4173a74ae8ff64fd2a3d84a08040296b41bb 100644 (file)
--- a/ext/standard/exec.c
+++ b/ext/standard/exec.c
@@ -216,9 +216,9 @@ static void php_exec_ex(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{ */
                Z_PARAM_STRING(cmd, cmd_len)
                Z_PARAM_OPTIONAL
                if (!mode) {
-                       Z_PARAM_ZVAL_DEREF(ret_array)
+                       Z_PARAM_ZVAL(ret_array)
                }
-               Z_PARAM_ZVAL_DEREF(ret_code)
+               Z_PARAM_ZVAL(ret_code)
        ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
        if (!cmd_len) {
@@ -233,18 +233,20 @@ static void php_exec_ex(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{ */
        if (!ret_array) {
                ret = php_exec(mode, cmd, NULL, return_value);
        } else {
-               if (Z_TYPE_P(ret_array) != IS_ARRAY) {
-                       zval_ptr_dtor(ret_array);
-                       array_init(ret_array);
-               } else if (Z_REFCOUNT_P(ret_array) > 1) {
-                       zval_ptr_dtor(ret_array);
-                       ZVAL_ARR(ret_array, zend_array_dup(Z_ARR_P(ret_array)));
+               if (Z_TYPE_P(Z_REFVAL_P(ret_array)) == IS_ARRAY) {
+                       ZVAL_DEREF(ret_array);
+                       SEPARATE_ARRAY(ret_array);
+               } else {
+                       ret_array = zend_try_array_init(ret_array);
+                       if (!ret_array) {
+                               return;
+                       }
                }
+
                ret = php_exec(2, cmd, ret_array, return_value);
        }
        if (ret_code) {
-               zval_ptr_dtor(ret_code);
-               ZVAL_LONG(ret_code, ret);
+               ZEND_TRY_ASSIGN_LONG(ret_code, ret);
        }
 }
 /* }}} */

diff --git a/ext/standard/file.c b/ext/standard/file.c
index c962ba4824c6c1bc8b2980abd4d6b94ef759663a..93b58e9a94dddb7565604f514a5dfa073949ada9 100644 (file)
--- a/ext/standard/file.c
+++ b/ext/standard/file.c
@@ -343,7 +343,7 @@ PHP_FUNCTION(flock)
                Z_PARAM_RESOURCE(res)
                Z_PARAM_LONG(operation)
                Z_PARAM_OPTIONAL
-               Z_PARAM_ZVAL_DEREF(wouldblock)
+               Z_PARAM_ZVAL(wouldblock)
        ZEND_PARSE_PARAMETERS_END();
 
        PHP_STREAM_TO_ZVAL(stream, res);
@@ -355,15 +355,14 @@ PHP_FUNCTION(flock)
        }
 
        if (wouldblock) {
-               zval_ptr_dtor(wouldblock);
-               ZVAL_LONG(wouldblock, 0);
+               ZEND_TRY_ASSIGN_LONG(wouldblock, 0);
        }
 
        /* flock_values contains all possible actions if (operation & 4) we won't block on the lock */
        act = flock_values[act - 1] | (operation & PHP_LOCK_NB ? LOCK_NB : 0);
        if (php_stream_lock(stream, act)) {
                if (operation && errno == EWOULDBLOCK && wouldblock) {
-                       ZVAL_LONG(wouldblock, 1);
+                       ZEND_TRY_ASSIGN_LONG(wouldblock, 1);
                }
                RETURN_FALSE;
        }

diff --git a/ext/standard/fsock.c b/ext/standard/fsock.c
index 6fc7143cd6ee66e21867ea8eba8c69d369be6447..32e651d1e48ba0fc5e8b1a0e9dd4831f86bcab54 100644 (file)
--- a/ext/standard/fsock.c
+++ b/ext/standard/fsock.c
@@ -53,8 +53,8 @@ static void php_fsockopen_stream(INTERNAL_FUNCTION_PARAMETERS, int persistent)
                Z_PARAM_STRING(host, host_len)
                Z_PARAM_OPTIONAL
                Z_PARAM_LONG(port)
-               Z_PARAM_ZVAL_DEREF(zerrno)
-               Z_PARAM_ZVAL_DEREF(zerrstr)
+               Z_PARAM_ZVAL(zerrno)
+               Z_PARAM_ZVAL(zerrstr)
                Z_PARAM_DOUBLE(timeout)
        ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
@@ -79,15 +79,6 @@ static void php_fsockopen_stream(INTERNAL_FUNCTION_PARAMETERS, int persistent)
 #endif
        tv.tv_usec = conv % 1000000;
 
-       if (zerrno)     {
-               zval_ptr_dtor(zerrno);
-               ZVAL_LONG(zerrno, 0);
-       }
-       if (zerrstr) {
-               zval_ptr_dtor(zerrstr);
-               ZVAL_EMPTY_STRING(zerrstr);
-       }
-
        stream = php_stream_xport_create(hostname, hostname_len, REPORT_ERRORS,
                        STREAM_XPORT_CLIENT | STREAM_XPORT_CONNECT, hashkey, &tv, NULL, &errstr, &err);
 
@@ -102,22 +93,27 @@ static void php_fsockopen_stream(INTERNAL_FUNCTION_PARAMETERS, int persistent)
                efree(hashkey);
        }
 
-       if (stream == NULL)     {
+       if (stream == NULL) {
                if (zerrno) {
-                       zval_ptr_dtor(zerrno);
-                       ZVAL_LONG(zerrno, err);
+                       ZEND_TRY_ASSIGN_LONG(zerrno, err);
                }
-               if (zerrstr && errstr) {
-                       /* no need to dup; we need to efree buf anyway */
-                       zval_ptr_dtor(zerrstr);
-                       ZVAL_STR(zerrstr, errstr);
-               } else if (!zerrstr && errstr) {
-                       zend_string_release_ex(errstr, 0);
+               if (errstr) {
+                       if (zerrstr) {
+                               ZEND_TRY_ASSIGN_STR(zerrstr, errstr);
+                       }
+                       zend_string_release(errstr);
                }
 
                RETURN_FALSE;
        }
 
+       if (zerrno) {
+               ZEND_TRY_ASSIGN_LONG(zerrno, 0);
+       }
+       if (zerrstr) {
+               ZEND_TRY_ASSIGN_EMPTY_STRING(zerrstr);
+       }
+
        if (errstr) {
                zend_string_release_ex(errstr, 0);
        }

diff --git a/ext/standard/head.c b/ext/standard/head.c
index 302599f02ba5583fb9dd57ce16f7c6233e267fb5..be2b2668f05015395188b9e9308593f739214e0c 100644 (file)
--- a/ext/standard/head.c
+++ b/ext/standard/head.c
@@ -358,8 +358,8 @@ PHP_FUNCTION(headers_sent)
 
        ZEND_PARSE_PARAMETERS_START(0, 2)
                Z_PARAM_OPTIONAL
-               Z_PARAM_ZVAL_DEREF(arg1)
-               Z_PARAM_ZVAL_DEREF(arg2)
+               Z_PARAM_ZVAL(arg1)
+               Z_PARAM_ZVAL(arg2)
        ZEND_PARSE_PARAMETERS_END();
 
        if (SG(headers_sent)) {
@@ -369,14 +369,12 @@ PHP_FUNCTION(headers_sent)
 
        switch(ZEND_NUM_ARGS()) {
        case 2:
-               zval_ptr_dtor(arg2);
-               ZVAL_LONG(arg2, line);
+               ZEND_TRY_ASSIGN_LONG(arg2, line);
        case 1:
-               zval_ptr_dtor(arg1);
                if (file) {
-                       ZVAL_STRING(arg1, file);
+                       ZEND_TRY_ASSIGN_STRING(arg1, file);
                } else {
-                       ZVAL_EMPTY_STRING(arg1);
+                       ZEND_TRY_ASSIGN_EMPTY_STRING(arg1);
                }
                break;
        }

diff --git a/ext/standard/image.c b/ext/standard/image.c
index d32d1499f34e8623fc17ee4a74706c5b14eee1be..cf9ba12be8fa13f9603f39708820924bb1dc0db9 100644 (file)
--- a/ext/standard/image.c
+++ b/ext/standard/image.c
@@ -1493,12 +1493,14 @@ static void php_getimagesize_from_any(INTERNAL_FUNCTION_PARAMETERS, int mode) {
        ZEND_PARSE_PARAMETERS_START(1, 2)
                Z_PARAM_STRING(input, input_len)
                Z_PARAM_OPTIONAL
-               Z_PARAM_ZVAL_DEREF(info)
+               Z_PARAM_ZVAL(info)
        ZEND_PARSE_PARAMETERS_END();
 
        if (argc == 2) {
-               zval_ptr_dtor(info);
-               array_init(info);
+               info = zend_try_array_init(info);
+               if (!info) {
+                       return;
+               }
        }
 
        if (mode == FROM_PATH) {

diff --git a/ext/standard/incomplete_class.c b/ext/standard/incomplete_class.c
index 943dafaa43008cfdf4983ecececa85abd3f80752..87a17ab7f60c37f259773363cbc6879b96b216a3 100644 (file)
--- a/ext/standard/incomplete_class.c
+++ b/ext/standard/incomplete_class.c
@@ -60,9 +60,10 @@ static zval *incomplete_class_get_property(zval *object, zval *member, int type,
 }
 /* }}} */
 
-static void incomplete_class_write_property(zval *object, zval *member, zval *value, void **cache_slot) /* {{{ */
+static zval *incomplete_class_write_property(zval *object, zval *member, zval *value, void **cache_slot) /* {{{ */
 {
        incomplete_class_message(object, E_NOTICE);
+       return value;
 }
 /* }}} */
 

diff --git a/ext/standard/proc_open.c b/ext/standard/proc_open.c
index 612cdf0f88c52edb5d5118e3fc7048da654a3545..8347ea78645520bb6012e6a27d05c9b4ec4c4be2 100644 (file)
--- a/ext/standard/proc_open.c
+++ b/ext/standard/proc_open.c
@@ -447,7 +447,7 @@ PHP_FUNCTION(proc_open)
        ZEND_PARSE_PARAMETERS_START(3, 6)
                Z_PARAM_STRING(command, command_len)
                Z_PARAM_ARRAY(descriptorspec)
-               Z_PARAM_ZVAL_DEREF(pipes)
+               Z_PARAM_ZVAL(pipes)
                Z_PARAM_OPTIONAL
                Z_PARAM_STRING_EX(cwd, cwd_len, 1, 0)
                Z_PARAM_ARRAY_EX(environment, 1, 0)
@@ -862,6 +862,11 @@ PHP_FUNCTION(proc_open)
 #endif
        /* we forked/spawned and this is the parent */
 
+       pipes = zend_try_array_init(pipes);
+       if (!pipes) {
+               goto exit_fail;
+       }
+
        proc = (struct php_process_handle*)pemalloc(sizeof(struct php_process_handle), is_persistent);
        proc->is_persistent = is_persistent;
        proc->command = command;
@@ -873,9 +878,6 @@ PHP_FUNCTION(proc_open)
 #endif
        proc->env = env;
 
-       zval_ptr_dtor(pipes);
-       array_init(pipes);
-
 #if PHP_CAN_DO_PTS
        if (dev_ptmx >= 0) {
                close(dev_ptmx);

diff --git a/ext/standard/scanf.c b/ext/standard/scanf.c
index 37cce100ce4c22cadcab64c6f4672f2b354e97f0..6c7544004bfa0de0d6060edc22dc0fe5887631d8 100644 (file)
--- a/ext/standard/scanf.c
+++ b/ext/standard/scanf.c
@@ -739,9 +739,8 @@ literal:
                                        if (numVars && objIndex >= argCount) {
                                                break;
                                        } else if (numVars) {
-                                               current = Z_REFVAL(args[objIndex++]);
-                                               zval_ptr_dtor(current);
-                                               ZVAL_LONG(current, (zend_long)(string - baseString) );
+                                               current = args + objIndex++;
+                                               ZEND_TRY_ASSIGN_LONG(current, (zend_long) (string - baseString));
                                        } else {
                                                add_index_long(return_value, objIndex++, string - baseString);
                                        }
@@ -858,9 +857,8 @@ literal:
                                        if (numVars && objIndex >= argCount) {
                                                break;
                                        } else if (numVars) {
-                                               current = Z_REFVAL(args[objIndex++]);
-                                               zval_ptr_dtor(current);
-                                               ZVAL_STRINGL(current, string, end-string);
+                                               current = args + objIndex++;
+                                               ZEND_TRY_ASSIGN_STRINGL(current, string, end - string);
                                        } else {
                                                add_index_stringl(return_value, objIndex++, string, end-string);
                                        }
@@ -899,9 +897,8 @@ literal:
                                        if (numVars && objIndex >= argCount) {
                                                break;
                                        } else if (numVars) {
-                                               current = Z_REFVAL(args[objIndex++]);
-                                               zval_ptr_dtor(current);
-                                               ZVAL_STRINGL(current, string, end-string);
+                                               current = args + objIndex++;
+                                               ZEND_TRY_ASSIGN_STRINGL(current, string, end - string);
                                        } else {
                                                add_index_stringl(return_value, objIndex++, string, end-string);
                                        }
@@ -1052,10 +1049,9 @@ addToInt:
                                                if (numVars && objIndex >= argCount) {
                                                        break;
                                                } else if (numVars) {
-                                                 /* change passed value type to string */
-                                                       current = Z_REFVAL(args[objIndex++]);
-                                                       zval_ptr_dtor(current);
-                                                       ZVAL_STRING(current, buf);
+                                                        /* change passed value type to string */
+                                                       current = args + objIndex++;
+                                                       ZEND_TRY_ASSIGN_STRING(current, buf);
                                                } else {
                                                        add_index_string(return_value, objIndex++, buf);
                                                }
@@ -1063,9 +1059,8 @@ addToInt:
                                                if (numVars && objIndex >= argCount) {
                                                        break;
                                                } else if (numVars) {
-                                                       current = Z_REFVAL(args[objIndex++]);
-                                                       zval_ptr_dtor(current);
-                                                       ZVAL_LONG(current, value);
+                                                       current = args + objIndex++;
+                                                       ZEND_TRY_ASSIGN_LONG(current, value);
                                                } else {
                                                        add_index_long(return_value, objIndex++, value);
                                                }
@@ -1168,9 +1163,8 @@ addToFloat:
                                        if (numVars && objIndex >= argCount) {
                                                break;
                                        } else if (numVars) {
-                                               current = Z_REFVAL(args[objIndex++]);
-                                               zval_ptr_dtor(current);
-                                               ZVAL_DOUBLE(current, dvalue);
+                                               current = args + objIndex++;
+                                               ZEND_TRY_ASSIGN_DOUBLE(current, dvalue);
                                        } else {
                                                add_index_double(return_value, objIndex++, dvalue );
                                        }

diff --git a/ext/standard/streamsfuncs.c b/ext/standard/streamsfuncs.c
index 442091ad46c6861c6610b9cf469b297e9c749cf8..8f67b8b3fcbc6ef63fe42282b0d3057cf4a4b693 100644 (file)
--- a/ext/standard/streamsfuncs.c
+++ b/ext/standard/streamsfuncs.c
@@ -107,8 +107,8 @@ PHP_FUNCTION(stream_socket_client)
        ZEND_PARSE_PARAMETERS_START(1, 6)
                Z_PARAM_STR(host)
                Z_PARAM_OPTIONAL
-               Z_PARAM_ZVAL_DEREF(zerrno)
-               Z_PARAM_ZVAL_DEREF(zerrstr)
+               Z_PARAM_ZVAL(zerrno)
+               Z_PARAM_ZVAL(zerrstr)
                Z_PARAM_DOUBLE(timeout)
                Z_PARAM_LONG(flags)
                Z_PARAM_RESOURCE(zcontext)
@@ -129,13 +129,11 @@ PHP_FUNCTION(stream_socket_client)
        tv.tv_sec = conv / 1000000;
        tv.tv_usec = conv % 1000000;
 #endif
-       if (zerrno)     {
-               zval_ptr_dtor(zerrno);
-               ZVAL_LONG(zerrno, 0);
+       if (zerrno) {
+               ZEND_TRY_ASSIGN_LONG(zerrno, 0);
        }
        if (zerrstr) {
-               zval_ptr_dtor(zerrstr);
-               ZVAL_EMPTY_STRING(zerrstr);
+               ZEND_TRY_ASSIGN_EMPTY_STRING(zerrstr);
        }
 
        stream = php_stream_xport_create(ZSTR_VAL(host), ZSTR_LEN(host), REPORT_ERRORS,
@@ -156,14 +154,12 @@ PHP_FUNCTION(stream_socket_client)
                efree(hashkey);
        }
 
-       if (stream == NULL)     {
+       if (stream == NULL) {
                if (zerrno) {
-                       zval_ptr_dtor(zerrno);
-                       ZVAL_LONG(zerrno, err);
+                       ZEND_TRY_ASSIGN_LONG(zerrno, err);
                }
                if (zerrstr && errstr) {
-                       zval_ptr_dtor(zerrstr);
-                       ZVAL_STR(zerrstr, errstr);
+                       ZEND_TRY_ASSIGN_STR(zerrstr, errstr);
                } else if (errstr) {
                        zend_string_release_ex(errstr, 0);
                }
@@ -197,8 +193,8 @@ PHP_FUNCTION(stream_socket_server)
        ZEND_PARSE_PARAMETERS_START(1, 5)
                Z_PARAM_STRING(host, host_len)
                Z_PARAM_OPTIONAL
-               Z_PARAM_ZVAL_DEREF(zerrno)
-               Z_PARAM_ZVAL_DEREF(zerrstr)
+               Z_PARAM_ZVAL(zerrno)
+               Z_PARAM_ZVAL(zerrstr)
                Z_PARAM_LONG(flags)
                Z_PARAM_RESOURCE(zcontext)
        ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
@@ -209,13 +205,11 @@ PHP_FUNCTION(stream_socket_server)
                GC_ADDREF(context->res);
        }
 
-       if (zerrno)     {
-               zval_ptr_dtor(zerrno);
-               ZVAL_LONG(zerrno, 0);
+       if (zerrno) {
+               ZEND_TRY_ASSIGN_LONG(zerrno, 0);
        }
        if (zerrstr) {
-               zval_ptr_dtor(zerrstr);
-               ZVAL_EMPTY_STRING(zerrstr);
+               ZEND_TRY_ASSIGN_EMPTY_STRING(zerrstr);
        }
 
        stream = php_stream_xport_create(host, host_len, REPORT_ERRORS,
@@ -226,14 +220,12 @@ PHP_FUNCTION(stream_socket_server)
                php_error_docref(NULL, E_WARNING, "unable to connect to %s (%s)", host, errstr == NULL ? "Unknown error" : ZSTR_VAL(errstr));
        }
 
-       if (stream == NULL)     {
+       if (stream == NULL) {
                if (zerrno) {
-                       zval_ptr_dtor(zerrno);
-                       ZVAL_LONG(zerrno, err);
+                       ZEND_TRY_ASSIGN_LONG(zerrno, err);
                }
                if (zerrstr && errstr) {
-                       zval_ptr_dtor(zerrstr);
-                       ZVAL_STR(zerrstr, errstr);
+                       ZEND_TRY_ASSIGN_STR(zerrstr, errstr);
                } else if (errstr) {
                        zend_string_release_ex(errstr, 0);
                }
@@ -265,7 +257,7 @@ PHP_FUNCTION(stream_socket_accept)
                Z_PARAM_RESOURCE(zstream)
                Z_PARAM_OPTIONAL
                Z_PARAM_DOUBLE(timeout)
-               Z_PARAM_ZVAL_DEREF(zpeername)
+               Z_PARAM_ZVAL(zpeername)
        ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
        php_stream_from_zval(stream, zstream);
@@ -279,10 +271,6 @@ PHP_FUNCTION(stream_socket_accept)
        tv.tv_sec = conv / 1000000;
        tv.tv_usec = conv % 1000000;
 #endif
-       if (zpeername) {
-               zval_ptr_dtor(zpeername);
-               ZVAL_NULL(zpeername);
-       }
 
        if (0 == php_stream_xport_accept(stream, &clistream,
                                zpeername ? &peername : NULL,
@@ -291,7 +279,7 @@ PHP_FUNCTION(stream_socket_accept)
                                ) && clistream) {
 
                if (peername) {
-                       ZVAL_STR(zpeername, peername);
+                       ZEND_TRY_ASSIGN_STR(zpeername, peername);
                }
                php_stream_to_zval(clistream, return_value);
        } else {
@@ -387,14 +375,13 @@ PHP_FUNCTION(stream_socket_recvfrom)
                Z_PARAM_LONG(to_read)
                Z_PARAM_OPTIONAL
                Z_PARAM_LONG(flags)
-               Z_PARAM_ZVAL_DEREF(zremote)
+               Z_PARAM_ZVAL(zremote)
        ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
        php_stream_from_zval(stream, zstream);
 
        if (zremote) {
-               zval_ptr_dtor(zremote);
-               ZVAL_NULL(zremote);
+               ZEND_TRY_ASSIGN_NULL(zremote);
        }
 
        if (to_read <= 0) {
@@ -410,7 +397,7 @@ PHP_FUNCTION(stream_socket_recvfrom)
 
        if (recvd >= 0) {
                if (zremote && remote_addr) {
-                       ZVAL_STR(zremote, remote_addr);
+                       ZEND_TRY_ASSIGN_STR(zremote, remote_addr);
                }
                ZSTR_VAL(read_buf)[recvd] = '\0';
                ZSTR_LEN(read_buf) = recvd;

diff --git a/ext/standard/string.c b/ext/standard/string.c
index 26144eb166de3536a73a1b1b893d09a77cd4f77d..3839512eccc9c01286ac8f33a1ff449b54871c81 100644 (file)
--- a/ext/standard/string.c
+++ b/ext/standard/string.c
@@ -3655,16 +3655,12 @@ PHP_FUNCTION(similar_text)
                Z_PARAM_STR(t1)
                Z_PARAM_STR(t2)
                Z_PARAM_OPTIONAL
-               Z_PARAM_ZVAL_DEREF(percent)
+               Z_PARAM_ZVAL(percent)
        ZEND_PARSE_PARAMETERS_END();
 
-       if (ac > 2) {
-               convert_to_double_ex(percent);
-       }
-
        if (ZSTR_LEN(t1) + ZSTR_LEN(t2) == 0) {
                if (ac > 2) {
-                       Z_DVAL_P(percent) = 0;
+                       ZEND_TRY_ASSIGN_DOUBLE(percent, 0);
                }
 
                RETURN_LONG(0);
@@ -3673,7 +3669,7 @@ PHP_FUNCTION(similar_text)
        sim = php_similar_char(ZSTR_VAL(t1), ZSTR_LEN(t1), ZSTR_VAL(t2), ZSTR_LEN(t2));
 
        if (ac > 2) {
-               Z_DVAL_P(percent) = sim * 200.0 / (ZSTR_LEN(t1) + ZSTR_LEN(t2));
+               ZEND_TRY_ASSIGN_DOUBLE(percent, sim * 200.0 / (ZSTR_LEN(t1) + ZSTR_LEN(t2)));
        }
 
        RETURN_LONG(sim);
@@ -4442,7 +4438,7 @@ static void php_str_replace_common(INTERNAL_FUNCTION_PARAMETERS, int case_sensit
                Z_PARAM_ZVAL(replace)
                Z_PARAM_ZVAL(subject)
                Z_PARAM_OPTIONAL
-               Z_PARAM_ZVAL_DEREF(zcount)
+               Z_PARAM_ZVAL(zcount)
        ZEND_PARSE_PARAMETERS_END();
 
        /* Make sure we're dealing with strings and do the replacement. */
@@ -4479,8 +4475,7 @@ static void php_str_replace_common(INTERNAL_FUNCTION_PARAMETERS, int case_sensit
                count = php_str_replace_in_subject(search, replace, subject, return_value, case_sensitivity);
        }
        if (argc > 3) {
-               zval_ptr_dtor(zcount);
-               ZVAL_LONG(zcount, count);
+               ZEND_TRY_ASSIGN_LONG(zcount, count);
        }
 }
 /* }}} */
@@ -4906,7 +4901,7 @@ PHP_FUNCTION(parse_str)
        ZEND_PARSE_PARAMETERS_START(1, 2)
                Z_PARAM_STRING(arg, arglen)
                Z_PARAM_OPTIONAL
-               Z_PARAM_ZVAL_DEREF(arrayArg)
+               Z_PARAM_ZVAL(arrayArg)
        ZEND_PARSE_PARAMETERS_END();
 
        res = estrndup(arg, arglen);
@@ -4928,9 +4923,11 @@ PHP_FUNCTION(parse_str)
                        zend_throw_error(NULL, "Cannot re-assign $this");
                }
        } else  {
-               /* Clear out the array that was passed in. */
-               zval_ptr_dtor(arrayArg);
-               array_init(arrayArg);
+               arrayArg = zend_try_array_init(arrayArg);
+               if (!arrayArg) {
+                       return;
+               }
+
                sapi_module.treat_data(PARSE_STRING, res, arrayArg);
        }
 }

diff --git a/ext/standard/tests/array/extract_typed_ref.phpt b/ext/standard/tests/array/extract_typed_ref.phpt
new file mode 100644 (file)
index 0000000..8b697d5
--- /dev/null
+++ b/ext/standard/tests/array/extract_typed_ref.phpt
@@ -0,0 +1,23 @@
+--TEST--
+extract() into typed references must respect their type
+--FILE--
+<?php
+  
+class Test {
+       public int $i = 0;
+       public string $s = "";
+}
+
+$test = new Test;
+$i =& $test->i;
+$s =& $test->s;
+try {
+       extract(['i' => 'foo', 's' => 42]);
+} catch (TypeError $e) { echo $e->getMessage(), "\n"; }
+var_dump($test->i, $test->s);
+
+?>
+--EXPECT--
+Cannot assign string to reference held by property Test::$i of type int
+int(0)
+string(0) ""

diff --git a/ext/standard/tests/general_functions/settype_typed_property.phpt b/ext/standard/tests/general_functions/settype_typed_property.phpt
new file mode 100644 (file)
index 0000000..a206a4b
--- /dev/null
+++ b/ext/standard/tests/general_functions/settype_typed_property.phpt
@@ -0,0 +1,28 @@
+--TEST--
+Using settype() on a typed property
+--FILE--
+<?php
+
+class Test {
+    public int $x;
+}
+
+$test = new Test;
+$test->x = 42;
+settype($test->x, 'string');
+// Same as $test->x = (string) $test->x.
+// Leaves value unchanged due to coercion
+var_dump($test->x);
+
+try {
+    settype($test->x, 'array');
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+var_dump($test->x);
+
+?>
+--EXPECT--
+int(42)
+Cannot assign array to reference held by property Test::$x of type int
+int(42)

diff --git a/ext/standard/tests/serialize/typed_property_refs.phpt b/ext/standard/tests/serialize/typed_property_refs.phpt
new file mode 100644 (file)
index 0000000..9475e8a
--- /dev/null
+++ b/ext/standard/tests/serialize/typed_property_refs.phpt
@@ -0,0 +1,73 @@
+--TEST--
+unserialize with references to typed properties shall skip the references or fail
+--FILE--
+<?php
+
+class A {
+       public int $a;
+       public $b;
+}
+
+class B {
+       public $a;
+       public int $b;
+}
+
+class C {
+       public int $a;
+       public string $b;
+}
+
+class D {
+    public int $a;
+    public float $b;
+}
+
+var_dump(unserialize('O:1:"A":2:{s:1:"a";i:1;s:1:"b";R:2;}'));
+var_dump(unserialize('O:1:"B":2:{s:1:"a";i:1;s:1:"b";R:2;}'));
+
+try {
+    var_dump(unserialize('O:1:"A":2:{s:1:"a";N;s:1:"b";R:2;}'));
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    var_dump(unserialize('O:1:"B":2:{s:1:"a";N;s:1:"b";R:2;}'));
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    var_dump(unserialize('O:1:"C":2:{s:1:"a";i:1;s:1:"b";R:2;}'));
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    var_dump(unserialize('O:1:"C":2:{s:1:"b";s:1:"x";s:1:"a";R:2;}'));
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    var_dump(unserialize('O:1:"D":2:{s:1:"a";i:1;s:1:"b";R:2;}'));
+} catch (TypeError $e) {
+    echo $e->getMessage(), "\n";
+}
+
+?>
+--EXPECT--
+object(A)#1 (2) {
+  ["a"]=>
+  &int(1)
+  ["b"]=>
+  &int(1)
+}
+object(B)#1 (2) {
+  ["a"]=>
+  &int(1)
+  ["b"]=>
+  &int(1)
+}
+Typed property A::$a must be int, null used
+Typed property B::$b must be int, null used
+Typed property C::$b must be string, int used
+Typed property C::$a must be int, string used
+Reference with value of type int held by property D::$a of type int is not compatible with property D::$b of type float

diff --git a/ext/standard/type.c b/ext/standard/type.c
index 1a26e0eaa364a3e4487bc78f8871514b895e360b..bc1233e35d0a485c25f8fd7302799299ee0b9406 100644 (file)
--- a/ext/standard/type.c
+++ b/ext/standard/type.c
@@ -45,40 +45,46 @@ PHP_FUNCTION(settype)
 {
        zval *var;
        char *type;
-       size_t type_len = 0;
+       size_t type_len;
+       zval tmp;
 
        ZEND_PARSE_PARAMETERS_START(2, 2)
-               Z_PARAM_ZVAL_DEREF(var)
+               Z_PARAM_ZVAL(var)
                Z_PARAM_STRING(type, type_len)
        ZEND_PARSE_PARAMETERS_END();
 
+       ZVAL_COPY(&tmp, var);
        if (!strcasecmp(type, "integer")) {
-               convert_to_long(var);
+               convert_to_long(&tmp);
        } else if (!strcasecmp(type, "int")) {
-               convert_to_long(var);
+               convert_to_long(&tmp);
        } else if (!strcasecmp(type, "float")) {
-               convert_to_double(var);
+               convert_to_double(&tmp);
        } else if (!strcasecmp(type, "double")) { /* deprecated */
-               convert_to_double(var);
+               convert_to_double(&tmp);
        } else if (!strcasecmp(type, "string")) {
-               convert_to_string(var);
+               convert_to_string(&tmp);
        } else if (!strcasecmp(type, "array")) {
-               convert_to_array(var);
+               convert_to_array(&tmp);
        } else if (!strcasecmp(type, "object")) {
-               convert_to_object(var);
+               convert_to_object(&tmp);
        } else if (!strcasecmp(type, "bool")) {
-               convert_to_boolean(var);
+               convert_to_boolean(&tmp);
        } else if (!strcasecmp(type, "boolean")) {
-               convert_to_boolean(var);
+               convert_to_boolean(&tmp);
        } else if (!strcasecmp(type, "null")) {
-               convert_to_null(var);
+               convert_to_null(&tmp);
        } else if (!strcasecmp(type, "resource")) {
+               zval_ptr_dtor(&tmp);
                php_error_docref(NULL, E_WARNING, "Cannot convert to resource type");
                RETURN_FALSE;
        } else {
+               zval_ptr_dtor(&tmp);
                php_error_docref(NULL, E_WARNING, "Invalid type");
                RETURN_FALSE;
        }
+
+       zend_try_assign(var, &tmp);
        RETVAL_TRUE;
 }
 /* }}} */
@@ -357,7 +363,7 @@ PHP_FUNCTION(is_callable)
                Z_PARAM_ZVAL(var)
                Z_PARAM_OPTIONAL
                Z_PARAM_BOOL(syntax_only)
-               Z_PARAM_ZVAL_DEREF(callable_name)
+               Z_PARAM_ZVAL(callable_name)
        ZEND_PARSE_PARAMETERS_END();
 
        if (syntax_only) {
@@ -365,8 +371,7 @@ PHP_FUNCTION(is_callable)
        }
        if (ZEND_NUM_ARGS() > 2) {
                retval = zend_is_callable_ex(var, NULL, check_flags, &name, NULL, &error);
-               zval_ptr_dtor(callable_name);
-               ZVAL_STR(callable_name, name);
+               ZEND_TRY_ASSIGN_STR(callable_name, name);
        } else {
                retval = zend_is_callable_ex(var, NULL, check_flags, NULL, NULL, &error);
        }

diff --git a/ext/standard/var.c b/ext/standard/var.c
index 108bafca8bb4cf5111a3cb9078b7858a73f55712..27ec44f991049da580a8351905ffda1ea8349a1f 100644 (file)
--- a/ext/standard/var.c
+++ b/ext/standard/var.c
@@ -51,7 +51,7 @@ static void php_array_element_dump(zval *zv, zend_ulong index, zend_string *key,
 }
 /* }}} */
 
-static void php_object_property_dump(zval *zv, zend_ulong index, zend_string *key, int level) /* {{{ */
+static void php_object_property_dump(zend_property_info *prop_info, zval *zv, zend_ulong index, zend_string *key, int level) /* {{{ */
 {
        const char *prop_name, *class_name;
 
@@ -74,7 +74,18 @@ static void php_object_property_dump(zval *zv, zend_ulong index, zend_string *ke
                }
                ZEND_PUTS("]=>\n");
        }
-       php_var_dump(zv, level + 2);
+
+       if (Z_TYPE_P(zv) == IS_UNDEF) {
+               ZEND_ASSERT(prop_info->type);
+               php_printf("%*cuninitialized(%s%s)\n",
+                       level + 1, ' ',
+                       ZEND_TYPE_ALLOW_NULL(prop_info->type) ? "?" : "",
+                       ZEND_TYPE_IS_CLASS(prop_info->type) ?
+                               ZSTR_VAL(ZEND_TYPE_IS_CE(prop_info->type) ? ZEND_TYPE_CE(prop_info->type)->name : ZEND_TYPE_NAME(prop_info->type)) :
+                               zend_get_type_by_const(ZEND_TYPE_CODE(prop_info->type)));
+       } else {
+               php_var_dump(zv, level + 2);
+       }
 }
 /* }}} */
 
@@ -154,8 +165,19 @@ again:
                                zend_string *key;
                                zval *val;
 
-                               ZEND_HASH_FOREACH_KEY_VAL_IND(myht, num, key, val) {
-                                       php_object_property_dump(val, num, key, level);
+                               ZEND_HASH_FOREACH_KEY_VAL(myht, num, key, val) {
+                                       zend_property_info *prop_info = NULL;
+
+                                       if (Z_TYPE_P(val) == IS_INDIRECT) {
+                                               val = Z_INDIRECT_P(val);
+                                               if (key) {
+                                                       prop_info = zend_get_typed_property_info_for_slot(Z_OBJ_P(struc), val);
+                                               }
+                                       }
+
+                                       if (!Z_ISUNDEF_P(val) || prop_info) {
+                                               php_object_property_dump(prop_info, val, num, key, level);
+                                       }
                                } ZEND_HASH_FOREACH_END();
                                zend_release_properties(myht);
                        }
@@ -216,7 +238,7 @@ static void zval_array_element_dump(zval *zv, zend_ulong index, zend_string *key
 }
 /* }}} */
 
-static void zval_object_property_dump(zval *zv, zend_ulong index, zend_string *key, int level) /* {{{ */
+static void zval_object_property_dump(zend_property_info *prop_info, zval *zv, zend_ulong index, zend_string *key, int level) /* {{{ */
 {
        const char *prop_name, *class_name;
 
@@ -237,7 +259,17 @@ static void zval_object_property_dump(zval *zv, zend_ulong index, zend_string *k
                }
                ZEND_PUTS("]=>\n");
        }
-       php_debug_zval_dump(zv, level + 2);
+       if (prop_info && Z_TYPE_P(zv) == IS_UNDEF) {
+               ZEND_ASSERT(prop_info->type);
+               php_printf("%*cuninitialized(%s%s)\n",
+                       level + 1, ' ',
+                       ZEND_TYPE_ALLOW_NULL(prop_info->type) ? "?" : "",
+                       ZEND_TYPE_IS_CLASS(prop_info->type) ?
+                               ZSTR_VAL(ZEND_TYPE_IS_CE(prop_info->type) ? ZEND_TYPE_CE(prop_info->type)->name : ZEND_TYPE_NAME(prop_info->type)) :
+                               zend_get_type_by_const(ZEND_TYPE_CODE(prop_info->type)));
+       } else {
+               php_debug_zval_dump(zv, level + 2);
+       }
 }
 /* }}} */
 
@@ -313,8 +345,19 @@ again:
                php_printf("%sobject(%s)#%d (%d) refcount(%u){\n", COMMON, ZSTR_VAL(class_name), Z_OBJ_HANDLE_P(struc), myht ? zend_array_count(myht) : 0, Z_REFCOUNT_P(struc));
                zend_string_release_ex(class_name, 0);
                if (myht) {
-                       ZEND_HASH_FOREACH_KEY_VAL_IND(myht, index, key, val) {
-                               zval_object_property_dump(val, index, key, level);
+                       ZEND_HASH_FOREACH_KEY_VAL(myht, index, key, val) {
+                               zend_property_info *prop_info = NULL;
+
+                               if (Z_TYPE_P(val) == IS_INDIRECT) {
+                                       val = Z_INDIRECT_P(val);
+                                       if (key) {
+                                               prop_info = zend_get_typed_property_info_for_slot(Z_OBJ_P(struc), val);
+                                       }
+                               }
+
+                               if (!Z_ISUNDEF_P(val) || prop_info) {
+                                       zval_object_property_dump(prop_info, val, index, key, level);
+                               }
                        } ZEND_HASH_FOREACH_END();
                        GC_UNPROTECT_RECURSION(myht);
                        zend_release_properties(myht);

diff --git a/ext/standard/var_unserializer.re b/ext/standard/var_unserializer.re
index d07d6577199ee14e16fb3ad9fb5d16ac44dace3b..8dad71450e94df2457e4e0c421994178578fb13f 100644 (file)
--- a/ext/standard/var_unserializer.re
+++ b/ext/standard/var_unserializer.re
@@ -46,6 +46,7 @@ struct php_unserialize_data {
        var_dtor_entries *first_dtor;
        var_dtor_entries *last_dtor;
        HashTable        *allowed_classes;
+       HashTable        *ref_props;
        var_entries       entries;
 };
 
@@ -57,6 +58,7 @@ PHPAPI php_unserialize_data_t php_var_unserialize_init() {
                d->last = &d->entries;
                d->first_dtor = d->last_dtor = NULL;
                d->allowed_classes = NULL;
+               d->ref_props = NULL;
                d->entries.used_slots = 0;
                d->entries.next = NULL;
                if (!BG(serialize_lock)) {
@@ -239,6 +241,11 @@ PHPAPI void var_destroy(php_unserialize_data_t *var_hashx)
        }
 
        zval_ptr_dtor_nogc(&wakeup_name);
+
+       if ((*var_hashx)->ref_props) {
+               zend_hash_destroy((*var_hashx)->ref_props);
+               FREE_HASHTABLE((*var_hashx)->ref_props);
+       }
 }
 
 /* }}} */
@@ -395,11 +402,12 @@ static inline size_t parse_uiv(const unsigned char *p)
 
 static int php_var_unserialize_internal(UNSERIALIZE_PARAMETER, int as_key);
 
-static zend_always_inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTable *ht, zend_long elements, int objprops)
+static zend_always_inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTable *ht, zend_long elements, zend_object *obj)
 {
        while (elements-- > 0) {
                zval key, *data, d, *old_data;
                zend_ulong idx;
+               zend_property_info *info = NULL;
 
                ZVAL_UNDEF(&key);
 
@@ -411,7 +419,7 @@ static zend_always_inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTab
                data = NULL;
                ZVAL_UNDEF(&d);
 
-               if (!objprops) {
+               if (!obj) {
                        if (Z_TYPE(key) == IS_LONG) {
                                idx = Z_LVAL(key);
 numeric_key:
@@ -440,8 +448,7 @@ numeric_key:
                } else {
                        if (EXPECTED(Z_TYPE(key) == IS_STRING)) {
 string_key:
-                               if (Z_TYPE_P(rval) == IS_OBJECT
-                                               && zend_hash_num_elements(&Z_OBJCE_P(rval)->properties_info) > 0) {
+                               if (obj && zend_hash_num_elements(&obj->ce->properties_info) > 0) {
                                        zend_property_info *existing_propinfo;
                                        zend_string *new_key;
                                        const char *unmangled_class = NULL;
@@ -456,8 +463,8 @@ string_key:
 
                                        unmangled = zend_string_init(unmangled_prop, unmangled_prop_len, 0);
 
-                                       existing_propinfo = zend_hash_find_ptr(&Z_OBJCE_P(rval)->properties_info, unmangled);
-                    if ((unmangled_class == NULL || !strcmp(unmangled_class, "*") || !strcasecmp(unmangled_class, ZSTR_VAL(Z_OBJCE_P(rval)->name)))
+                                       existing_propinfo = zend_hash_find_ptr(&obj->ce->properties_info, unmangled);
+                    if ((unmangled_class == NULL || !strcmp(unmangled_class, "*") || !strcasecmp(unmangled_class, ZSTR_VAL(obj->ce->name)))
                             && (existing_propinfo != NULL)
                                                        && (existing_propinfo->flags & ZEND_ACC_PPP_MASK)) {
                                                if (existing_propinfo->flags & ZEND_ACC_PROTECTED) {
@@ -491,9 +498,24 @@ string_key:
                                if ((old_data = zend_hash_find(ht, Z_STR(key))) != NULL) {
                                        if (Z_TYPE_P(old_data) == IS_INDIRECT) {
                                                old_data = Z_INDIRECT_P(old_data);
+                                               info = zend_get_typed_property_info_for_slot(obj, old_data);
+                                               var_push_dtor(var_hash, old_data);
+                                               data = zend_hash_update_ind(ht, Z_STR(key), &d);
+
+                                               if (UNEXPECTED(info)) {
+                                                       /* Remember to which property this slot belongs, so we can add a
+                                                        * type source if it is turned into a reference lateron. */
+                                                       if (!(*var_hash)->ref_props) {
+                                                               (*var_hash)->ref_props = emalloc(sizeof(HashTable));
+                                                               zend_hash_init((*var_hash)->ref_props, 8, NULL, NULL, 0);
+                                                       }
+                                                       zend_hash_index_update_ptr(
+                                                               (*var_hash)->ref_props, (zend_uintptr_t) data, info);
+                                               }
+                                       } else {
+                                               var_push_dtor(var_hash, old_data);
+                                               data = zend_hash_update_ind(ht, Z_STR(key), &d);
                                        }
-                                       var_push_dtor(var_hash, old_data);
-                                       data = zend_hash_update_ind(ht, Z_STR(key), &d);
                                } else {
                                        data = zend_hash_add_new(ht, Z_STR(key), &d);
                                }
@@ -512,6 +534,18 @@ string_key:
                        return 0;
                }
 
+               if (UNEXPECTED(info)) {
+                       if (!zend_verify_prop_assignable_by_ref(info, data, /* strict */ 1)) {
+                               zval_ptr_dtor(data);
+                               ZVAL_UNDEF(data);
+                               zval_dtor(&key);
+                               return 0;
+                       }
+                       if (Z_ISREF_P(data)) {
+                               ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(data), info);
+                       }
+               }
+
                if (BG(unserialize).level > 1) {
                        var_push_dtor(var_hash, data);
                }
@@ -613,7 +647,7 @@ static inline int object_common2(UNSERIALIZE_PARAMETER, zend_long elements)
        }
 
        zend_hash_extend(ht, zend_hash_num_elements(ht) + elements, HT_FLAGS(ht) & HASH_FLAG_PACKED);
-       if (!process_nested_data(UNSERIALIZE_PASSTHRU, ht, elements, 1)) {
+       if (!process_nested_data(UNSERIALIZE_PASSTHRU, ht, elements, Z_OBJ_P(rval))) {
                if (has_wakeup) {
                        ZVAL_DEREF(rval);
                        GC_ADD_FLAGS(Z_OBJ_P(rval), IS_OBJ_DESTRUCTOR_CALLED);
@@ -697,13 +731,19 @@ static int php_var_unserialize_internal(UNSERIALIZE_PARAMETER, int as_key)
                return 0;
        }
 
-       if (Z_ISREF_P(rval_ref)) {
-               ZVAL_COPY(rval, rval_ref);
-       } else {
+       if (!Z_ISREF_P(rval_ref)) {
+               zend_property_info *info = NULL;
+               if ((*var_hash)->ref_props) {
+                       info = zend_hash_index_find_ptr((*var_hash)->ref_props, (zend_uintptr_t) rval_ref);
+               }
                ZVAL_NEW_REF(rval_ref, rval_ref);
-               ZVAL_COPY(rval, rval_ref);
+               if (info) {
+                       ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(rval_ref), info);
+               }
        }
 
+       ZVAL_COPY(rval, rval_ref);
+
        return 1;
 }
 
@@ -901,7 +941,7 @@ use_double:
         * prohibit "r:" references to non-objects, as we only generate them for objects. */
        HT_ALLOW_COW_VIOLATION(Z_ARRVAL_P(rval));
 
-       if (!process_nested_data(UNSERIALIZE_PASSTHRU, Z_ARRVAL_P(rval), elements, 0)) {
+       if (!process_nested_data(UNSERIALIZE_PASSTHRU, Z_ARRVAL_P(rval), elements, NULL)) {
                return 0;
        }
 

diff --git a/ext/sysvmsg/sysvmsg.c b/ext/sysvmsg/sysvmsg.c
index a00b73ee8a4c9b29cb02b8eb51beafbf83f3cbb1..0f7726f334b78dd2629d0be251d074e05c306c24 100644 (file)
--- a/ext/sysvmsg/sysvmsg.c
+++ b/ext/sysvmsg/sysvmsg.c
@@ -318,7 +318,7 @@ PHP_FUNCTION(msg_remove_queue)
 }
 /* }}} */
 
-/* {{{ proto mixed msg_receive(resource queue, int desiredmsgtype, int &msgtype, int maxsize, mixed message [, bool unserialize=true [, int flags=0 [, int errorcode]]])
+/* {{{ proto mixed msg_receive(resource queue, int desiredmsgtype, int &msgtype, int maxsize, mixed &message [, bool unserialize=true [, int flags=0 [, int &errorcode]]])
    Send a message of type msgtype (must be > 0) to a message queue */
 PHP_FUNCTION(msg_receive)
 {
@@ -332,7 +332,7 @@ PHP_FUNCTION(msg_receive)
 
        RETVAL_FALSE;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rlz/lz/|blz/",
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rlzlz|blz",
                                &queue, &desiredmsgtype, &out_msgtype, &maxsize,
                                &out_message, &do_unserialize, &flags, &zerrcode) == FAILURE) {
                return;
@@ -368,19 +368,12 @@ PHP_FUNCTION(msg_receive)
 
        result = msgrcv(mq->id, messagebuffer, maxsize, desiredmsgtype, realflags);
 
-       zval_ptr_dtor(out_msgtype);
-       zval_ptr_dtor(out_message);
-       ZVAL_LONG(out_msgtype, 0);
-       ZVAL_FALSE(out_message);
-
-       if (zerrcode) {
-               zval_ptr_dtor(zerrcode);
-               ZVAL_LONG(zerrcode, 0);
-       }
-
        if (result >= 0) {
                /* got it! */
-               ZVAL_LONG(out_msgtype, messagebuffer->mtype);
+               ZEND_TRY_ASSIGN_LONG(out_msgtype, messagebuffer->mtype);
+               if (zerrcode) {
+                       ZEND_TRY_ASSIGN_LONG(zerrcode, 0);
+               }
 
                RETVAL_TRUE;
                if (do_unserialize)     {
@@ -391,16 +384,21 @@ PHP_FUNCTION(msg_receive)
                        PHP_VAR_UNSERIALIZE_INIT(var_hash);
                        if (!php_var_unserialize(&tmp, &p, p + result, &var_hash)) {
                                php_error_docref(NULL, E_WARNING, "message corrupted");
+                               ZEND_TRY_ASSIGN_FALSE(out_message);
                                RETVAL_FALSE;
                        } else {
-                               ZVAL_COPY_VALUE(out_message, &tmp);
+                               ZEND_TRY_ASSIGN_VALUE(out_message, &tmp);
                        }
                        PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
                } else {
-                       ZVAL_STRINGL(out_message, messagebuffer->mtext, result);
+                       ZEND_TRY_ASSIGN_STRINGL(out_message, messagebuffer->mtext, result);
+               }
+       } else {
+               ZEND_TRY_ASSIGN_LONG(out_msgtype, 0);
+               ZEND_TRY_ASSIGN_FALSE(out_message);
+               if (zerrcode) {
+                       ZEND_TRY_ASSIGN_LONG(zerrcode, errno);
                }
-       } else if (zerrcode) {
-               ZVAL_LONG(zerrcode, errno);
        }
        efree(messagebuffer);
 }
@@ -420,7 +418,7 @@ PHP_FUNCTION(msg_send)
 
        RETVAL_FALSE;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rlz|bbz/",
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rlz|bbz",
                                &queue, &msgtype, &message, &do_serialize, &blocking, &zerror) == FAILURE) {
                return;
        }
@@ -486,8 +484,7 @@ PHP_FUNCTION(msg_send)
        if (result == -1) {
                php_error_docref(NULL, E_WARNING, "msgsnd failed: %s", strerror(errno));
                if (zerror) {
-                       zval_ptr_dtor(zerror);
-                       ZVAL_LONG(zerror, errno);
+                       ZEND_TRY_ASSIGN_LONG(zerror, errno);
                }
        } else {
                RETVAL_TRUE;

diff --git a/ext/xml/xml.c b/ext/xml/xml.c
index 9868c5e3c4ca5b16ee7caa1c2c547570f5494b9b..d5f2a51312a193a92d1a0753f70af5b6e48525eb 100644 (file)
--- a/ext/xml/xml.c
+++ b/ext/xml/xml.c
@@ -1434,21 +1434,25 @@ PHP_FUNCTION(xml_parse_into_struct)
        size_t data_len;
        int ret;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rsz/|z/", &pind, &data, &data_len, &xdata, &info) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "rsz|z", &pind, &data, &data_len, &xdata, &info) == FAILURE) {
                return;
        }
 
        if (info) {
-               zval_ptr_dtor(info);
-               array_init(info);
+               info = zend_try_array_init(info);
+               if (!info) {
+                       return;
+               }
        }
 
        if ((parser = (xml_parser *)zend_fetch_resource(Z_RES_P(pind), "XML Parser", le_xml_parser)) == NULL) {
                RETURN_FALSE;
        }
 
-       zval_ptr_dtor(xdata);
-       array_init(xdata);
+       xdata = zend_try_array_init(xdata);
+       if (!xdata) {
+               return;
+       }
 
        ZVAL_COPY_VALUE(&parser->data, xdata);
 

diff --git a/ext/xmlreader/php_xmlreader.c b/ext/xmlreader/php_xmlreader.c
index ba5c854aee279640ed2d5af5aa9fedc163a17d74..2710be98c6512b76919b164baae1346bb371fcd3 100644 (file)
--- a/ext/xmlreader/php_xmlreader.c
+++ b/ext/xmlreader/php_xmlreader.c
@@ -181,7 +181,7 @@ zval *xmlreader_read_property(zval *object, zval *member, int type, void **cache
 /* }}} */
 
 /* {{{ xmlreader_write_property */
-void xmlreader_write_property(zval *object, zval *member, zval *value, void **cache_slot)
+zval *xmlreader_write_property(zval *object, zval *member, zval *value, void **cache_slot)
 {
        xmlreader_object *obj;
        zval tmp_member;
@@ -200,12 +200,14 @@ void xmlreader_write_property(zval *object, zval *member, zval *value, void **ca
        if (hnd != NULL) {
                php_error_docref(NULL, E_WARNING, "Cannot write to read-only property");
        } else {
-               zend_std_write_property(object, member, value, cache_slot);
+               value = zend_std_write_property(object, member, value, cache_slot);
        }
 
        if (member == &tmp_member) {
                zval_ptr_dtor_str(&tmp_member);
        }
+
+       return value;
 }
 /* }}} */
 

diff --git a/ext/xmlrpc/xmlrpc-epi-php.c b/ext/xmlrpc/xmlrpc-epi-php.c
index 737a3f84a5127a0132984756e5615ba215d1a7ce..937f7b1b0f532c9583c30682dd358264109c9736 100644 (file)
--- a/ext/xmlrpc/xmlrpc-epi-php.c
+++ b/ext/xmlrpc/xmlrpc-epi-php.c
@@ -764,11 +764,9 @@ void decode_request_worker(char *xml_in, int xml_in_len, char *encoding_in, zval
                        if (method_name_out) {
                                method_name = XMLRPC_RequestGetMethodName(response);
                                if (method_name) {
-                                       zval_ptr_dtor(method_name_out);
-                                       ZVAL_STRING(method_name_out, method_name);
+                                       ZEND_TRY_ASSIGN_STRING(method_name_out, method_name);
                                } else {
-                                       zval_ptr_dtor(retval);
-                                       ZVAL_NULL(retval);
+                                       ZEND_TRY_ASSIGN_NULL(retval);
                                }
                        }
                }
@@ -787,7 +785,7 @@ PHP_FUNCTION(xmlrpc_decode_request)
        zval *method;
        size_t xml_len, encoding_len = 0;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz/|s", &xml, &xml_len, &method, &encoding, &encoding_len) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz|s", &xml, &xml_len, &method, &encoding, &encoding_len) == FAILURE) {
                return;
        }
 
@@ -1389,15 +1387,19 @@ PHP_FUNCTION(xmlrpc_set_type)
        size_t type_len;
        XMLRPC_VALUE_TYPE vtype;
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "z/s", &arg, &type, &type_len) == FAILURE) {
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "zs", &arg, &type, &type_len) == FAILURE) {
                return;
        }
 
        vtype = xmlrpc_str_as_type(type);
        if (vtype != xmlrpc_none) {
-               if (set_zval_xmlrpc_type(arg, vtype) == SUCCESS) {
+               zval tmp;
+               ZVAL_COPY(&tmp, Z_REFVAL_P(arg));
+               if (set_zval_xmlrpc_type(&tmp, vtype) == SUCCESS) {
+                       ZEND_TRY_ASSIGN_VALUE(arg, &tmp);
                        RETURN_TRUE;
                }
+               Z_TRY_DELREF(tmp);
        } else {
                zend_error(E_WARNING,"invalid type '%s' passed to xmlrpc_set_type()", type);
        }

diff --git a/ext/zend_test/test.c b/ext/zend_test/test.c
index 31455daab86875832ccc5eef2d30d6911cec547f..8d533b7907389210b0e03bda49af148c7812cce1 100644 (file)
--- a/ext/zend_test/test.c
+++ b/ext/zend_test/test.c
@@ -137,6 +137,7 @@ ZEND_FUNCTION(zend_leak_variable)
 
 static zend_object *zend_test_class_new(zend_class_entry *class_type) /* {{{ */ {
        zend_object *obj = zend_objects_new(class_type);
+       object_properties_init(obj, class_type);
        obj->handlers = &zend_test_class_handlers;
        return obj;
 }
@@ -203,6 +204,36 @@ PHP_MINIT_FUNCTION(zend_test)
 
        zend_declare_property_null(zend_test_class, "_StaticProp", sizeof("_StaticProp") - 1, ZEND_ACC_STATIC);
 
+       {
+               zend_string *name = zend_string_init("intProp", sizeof("intProp") - 1, 1);
+               zval val;
+               ZVAL_LONG(&val, 123);
+               zend_declare_typed_property(
+                       zend_test_class, name, &val, ZEND_ACC_PUBLIC, NULL, ZEND_TYPE_ENCODE(IS_LONG, 0));
+               zend_string_release(name);
+       }
+
+       {
+               zend_string *name = zend_string_init("classProp", sizeof("classProp") - 1, 1);
+               zend_string *class_name = zend_string_init("stdClass", sizeof("stdClass") - 1, 1);
+               zval val;
+               ZVAL_NULL(&val);
+               zend_declare_typed_property(
+                       zend_test_class, name, &val, ZEND_ACC_PUBLIC, NULL,
+                       ZEND_TYPE_ENCODE_CLASS(class_name, 1));
+               zend_string_release(name);
+       }
+
+       {
+               zend_string *name = zend_string_init("staticIntProp", sizeof("staticIntProp") - 1, 1);
+               zval val;
+               ZVAL_LONG(&val, 123);
+               zend_declare_typed_property(
+                       zend_test_class, name, &val, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC, NULL,
+                       ZEND_TYPE_ENCODE(IS_LONG, 0));
+               zend_string_release(name);
+       }
+
        INIT_CLASS_ENTRY(class_entry, "_ZendTestChildClass", NULL);
        zend_test_child_class = zend_register_internal_class_ex(&class_entry, zend_test_class);
 

diff --git a/ext/zip/php_zip.c b/ext/zip/php_zip.c
index 5aa17fb6691ffd93f3f81d8551e5081caa4422d1..dbc6c1603ee0a2a1dc41067aa0d2f5555ded4d50 100644 (file)
--- a/ext/zip/php_zip.c
+++ b/ext/zip/php_zip.c
@@ -2133,7 +2133,7 @@ static ZIPARCHIVE_METHOD(getExternalAttributesName)
 
        ZIP_FROM_OBJECT(intern, self);
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "sz/z/|l",
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "szz|l",
                        &name, &name_len, &z_opsys, &z_attr, &flags) == FAILURE) {
                return;
        }
@@ -2150,10 +2150,8 @@ static ZIPARCHIVE_METHOD(getExternalAttributesName)
                        (zip_flags_t)flags, &opsys, &attr) < 0) {
                RETURN_FALSE;
        }
-       zval_ptr_dtor(z_opsys);
-       ZVAL_LONG(z_opsys, opsys);
-       zval_ptr_dtor(z_attr);
-       ZVAL_LONG(z_attr, attr);
+       ZEND_TRY_ASSIGN_LONG(z_opsys, opsys);
+       ZEND_TRY_ASSIGN_LONG(z_attr, attr);
        RETURN_TRUE;
 }
 /* }}} */
@@ -2171,7 +2169,7 @@ static ZIPARCHIVE_METHOD(getExternalAttributesIndex)
 
        ZIP_FROM_OBJECT(intern, self);
 
-       if (zend_parse_parameters(ZEND_NUM_ARGS(), "lz/z/|l",
+       if (zend_parse_parameters(ZEND_NUM_ARGS(), "lzz|l",
                        &index, &z_opsys, &z_attr, &flags) == FAILURE) {
                return;
        }
@@ -2181,10 +2179,8 @@ static ZIPARCHIVE_METHOD(getExternalAttributesIndex)
                        (zip_flags_t)flags, &opsys, &attr) < 0) {
                RETURN_FALSE;
        }
-       zval_ptr_dtor(z_opsys);
-       ZVAL_LONG(z_opsys, opsys);
-       zval_ptr_dtor(z_attr);
-       ZVAL_LONG(z_attr, attr);
+       ZEND_TRY_ASSIGN_LONG(z_opsys, opsys);
+       ZEND_TRY_ASSIGN_LONG(z_attr, attr);
        RETURN_TRUE;
 }
 /* }}} */

diff --git a/tests/classes/array_access_012.phpt b/tests/classes/array_access_012.phpt
index ba3d6780f1de61b988ea26f34076e1f355cef3ac..3cd3dceb8a4e267ea8128bb05f92b677155798a0 100644 (file)
--- a/tests/classes/array_access_012.phpt
+++ b/tests/classes/array_access_012.phpt
@@ -32,7 +32,7 @@ $data['element'] = &$test;
 --EXPECTF--
 Notice: Indirect modification of overloaded element of ArrayAccessImpl has no effect in %sarray_access_012.php on line 24
 
-Fatal error: Uncaught Error: Cannot assign by reference to overloaded object in %sarray_access_012.php:24
+Fatal error: Uncaught Error: Cannot assign by reference to an array dimension of an object in %sarray_access_012.php:24
 Stack trace:
 #0 {main}
   thrown in %sarray_access_012.php on line 24