diff options
210 files changed, 22529 insertions, 5445 deletions
@@ -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 2335e76635..e4147f249c 100644 --- 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 index 0000000000..6e34cb478f --- /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 index 0000000000..3aec7a34ba --- /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 index 0000000000..59c289a566 --- /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 index 0000000000..03d9e41aac --- /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 index 0000000000..b521963000 --- /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 index 0000000000..c3a8faefd4 --- /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 index 0000000000..19e8022a24 --- /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 index 0000000000..70b4282626 --- /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 index 0000000000..24013b4118 --- /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 index 0000000000..fd7d367fea --- /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 index 0000000000..706a332750 --- /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 index 0000000000..79a77cfa40 --- /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 index 0000000000..01c2f4b6a0 --- /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 index 0000000000..2a02f0381e --- /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 index 0000000000..ac11c0fe3e --- /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 index 0000000000..e2b98a096d --- /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 index 0000000000..3e501d3688 --- /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 index 0000000000..097b39b232 --- /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 index 0000000000..d804b9c799 --- /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 index 0000000000..d32d17b1c8 --- /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 index 0000000000..a9f82528d9 --- /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 index 0000000000..7e947825c9 --- /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 index 0000000000..1531b23b95 --- /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 index 0000000000..96f7216687 --- /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 index 0000000000..65187c1e17 --- /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 index 0000000000..a2c4e25e33 --- /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 index 0000000000..861769932c --- /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 index 0000000000..de1b3f6602 --- /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 index 0000000000..a5418c91a8 --- /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 index 0000000000..a835ae5fae --- /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 index 0000000000..8022d2ef72 --- /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 index 0000000000..f3ceeb5cd9 --- /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 index 0000000000..87e6aef26b --- /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 index 0000000000..c3885af39f --- /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 index 0000000000..923f7a2a85 --- /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 index 0000000000..edb87a38e0 --- /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 index 0000000000..c5dde53572 --- /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 index 0000000000..44e5d04c7f --- /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 index 0000000000..62413d804c --- /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 index 0000000000..db2b90903c --- /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 index 0000000000..76dbfd8f5d --- /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 index 0000000000..ecb3df3c11 --- /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 index 0000000000..eefe358796 --- /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 index 0000000000..02a71a7b0b --- /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 index 0000000000..7e4dc8e43f --- /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 index 0000000000..050e64a2a4 --- /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 index 0000000000..7f1e573cd3 --- /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 index 0000000000..8a06c55f23 --- /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 index 0000000000..e761590548 --- /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 index 0000000000..3fa826083e --- /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 index 0000000000..1c8673d0d3 --- /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 index 0000000000..3a73d7359a --- /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 index 0000000000..1da42bcbd9 --- /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 index 0000000000..38de9815ed --- /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 index 0000000000..31d687254c --- /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 index 0000000000..54013f44f2 --- /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 index 0000000000..6b53a42600 --- /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 index 0000000000..d9283bdbef --- /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 index 0000000000..caee8501f7 --- /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 index 0000000000..559349b7a9 --- /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 index 0000000000..647543c6d6 --- /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 index 0000000000..45f4682806 --- /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 index 0000000000..bd4cccff22 --- /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 index 0000000000..59e0552898 --- /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 index 0000000000..da88cbf2cb --- /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 index 0000000000..a91a00df65 --- /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 index 0000000000..da6865e5d4 --- /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 index 0000000000..7ed58d2a00 --- /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 index 0000000000..77cfc02487 --- /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 index 0000000000..dd77c68355 --- /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 index 0000000000..4d0451cf73 --- /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 index 0000000000..b56c5d632e --- /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 index 0000000000..7f9b4ff2de --- /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 index 0000000000..8e6be312c6 --- /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 index 0000000000..5f3943cbee --- /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 index 0000000000..b0d0bfedf8 --- /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 index 0000000000..4e2640338f --- /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 index 0000000000..6645970dd4 --- /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 index 0000000000..85ed6fc75d --- /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 index 0000000000..58a17a1a96 --- /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 index 0000000000..4f49eae4e7 --- /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 index 0000000000..1e4e62e89b --- /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 index 0000000000..f67eec302a --- /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 index 0000000000..fb3c86115e --- /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 index 0000000000..ccac3768cb --- /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 index 0000000000..c58eb7898e --- /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 index 0000000000..b981dfc166 --- /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 index 0000000000..b2f626d3da --- /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 index 0000000000..1d59b8d945 --- /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 index 0000000000..3b75aaa843 --- /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 index 0000000000..7d6b54ae59 --- /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 index 0000000000..8509fa7446 --- /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 index 0000000000..f0c7ef51a9 --- /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 index 0000000000..0fbcb7ef55 --- /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 index 0000000000..edbef8dfc7 --- /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 index 0000000000..32191b241e --- /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 index 0000000000..b00f05980c --- /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 index 0000000000..48e443c458 --- /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 index 0000000000..1e450ce818 --- /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 index 0000000000..8ee3deb0f7 --- /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 index 0000000000..3c5a15fe40 --- /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 index 0000000000..83f3c26186 --- /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 index 0000000000..54619c23b7 --- /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 3143217b8d..3619a7808d 100644 --- 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 aadda0c3cc..5918691c27 100644 --- 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 02b89be61b..3154f4808f 100644 --- 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 2357a1a49d..27fc6cb011 100644 --- 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 08fde1d1b0..8ddf8ea9ab 100644 --- 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 008d5b19eb..9600b801ca 100644 --- 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 12aec3916e..c3dbf145e9 100644 --- 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 c5c9f1f475..7210cb4bab 100644 --- 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 892a7af423..07c8a1768f 100644 --- 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 4f334c6b86..363812e01f 100644 --- 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 72113e8fe7..1060b1f632 100644 --- 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 387c1ca4d7..9dc26088f7 100644 --- 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 bda628fc29..a882f6461f 100644 --- 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 ec9ba82193..c1902303c2 100644 --- 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 5f7e819531..e91202669b 100644 --- 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 fbb66f798a..c3b5fda42d 100644 --- 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 0051ce8438..19d17dc9e9 100644 --- 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 658c8407cf..2a569604fc 100644 --- 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 6ec0e2d1c8..ec624a5adb 100644 --- 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 ece1bdd900..f2b089631a 100644 --- 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 c057390700..d6e7236243 100644 --- 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 f78b961c72..22844ccc62 100644 --- 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 790e01b8f3..d24636c0f8 100644 --- 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)); +} + +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)); +} - if (UNEXPECTED(retval == NULL)) { +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; - } - } + result = zend_fetch_static_property_address(&value, NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0 OPLINE_CC EXECUTE_DATA_CC); - 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); - } - - 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; - 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(); } @@ -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); - } + 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); @@ -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); - } - - if (IS_CONST != 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); @@ -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)); +} - if (UNEXPECTED(retval == NULL)) { +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(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); - } + 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_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); - -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(); +} + +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; - 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(); } @@ -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; - } - } + result = zend_fetch_static_property_address(&value, NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0 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 { - 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); - -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; - } - } + result = zend_fetch_static_property_address(&value, NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0 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 { - 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); - -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); + } + + 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); @@ -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,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_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 @@ -24564,6 +27597,45 @@ 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)); +#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 + /* 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(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,13 +28206,12 @@ 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; } - 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; } @@ -25104,15 +28220,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_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); + 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); } @@ -25174,10 +28329,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: @@ -25204,13 +28359,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_ 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; } @@ -25219,15 +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_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); + } - 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); @@ -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); + } - 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); @@ -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)) { + result = zend_fetch_static_property_address(&value, NULL, opline->extended_value & ~ZEND_ISEMPTY, BP_VAR_IS, 0 OPLINE_CC EXECUTE_DATA_CC); - 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); - } - -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)); +} - 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_VAR(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); - if (UNEXPECTED(retval == NULL)) { + 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; + + 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,15 +56793,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_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); } @@ -49330,10 +56902,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: @@ -49360,13 +56932,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_ 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; } @@ -49375,15 +56946,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_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); } @@ -49445,10 +57055,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: @@ -49475,13 +57085,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_ 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; } @@ -49490,15 +57099,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_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); } @@ -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,13 +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, @@ -51532,15 +59446,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_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, @@ -51548,45 +59466,59 @@ ZEND_API void execute_ex(zend_execute_data *ex) (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,12 +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, @@ -51682,15 +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,15 +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, @@ -51835,12 +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,12 +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, @@ -51907,15 +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,14 +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, @@ -51984,59 +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,13 +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, @@ -52058,60 +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,14 +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, @@ -52134,59 +60246,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_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, (void*)&&ZEND_NULL_LABEL, (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,12 +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, @@ -52207,15 +60346,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_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, @@ -52223,45 +60366,59 @@ ZEND_API void execute_ex(zend_execute_data *ex) (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,14 +61890,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_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, @@ -53722,63 +61910,83 @@ 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_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, @@ -54092,6 +62300,381 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_LABEL, + (void*)&&ZEND_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, + (void*)&&ZEND_NULL_LABEL, + (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_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_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_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_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_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_STATIC_PROP_SPEC_CONST_UNUSED_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_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_NULL_LABEL, + (void*)&&ZEND_NULL_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_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_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_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_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_NULL_LABEL, + (void*)&&ZEND_NULL_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_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_ASSIGN_STATIC_PROP_SPEC_TMPVAR_UNUSED_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_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_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_NULL_LABEL, + (void*)&&ZEND_NULL_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_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_ASSIGN_STATIC_PROP_SPEC_CV_UNUSED_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_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_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_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_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_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_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_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_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_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_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_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_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_POST_INC_STATIC_PROP_SPEC_CV_CONST_LABEL, + (void*)&&ZEND_NULL_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_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_POST_DEC_STATIC_PROP_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_NULL_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_POST_DEC_STATIC_PROP_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_NULL_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_NULL_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_POST_DEC_STATIC_PROP_SPEC_CV_VAR_LABEL, + (void*)&&ZEND_POST_DEC_STATIC_PROP_SPEC_CV_UNUSED_LABEL, + (void*)&&ZEND_NULL_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,13 +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, @@ -61239,60 +70849,79 @@ 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, ZEND_NULL_HANDLER, 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,14 +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, @@ -61315,59 +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,12 +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, @@ -61388,15 +71049,19 @@ 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, @@ -61404,45 +71069,59 @@ void zend_vm_init(void) 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,14 +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, @@ -61465,59 +71149,79 @@ 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, ZEND_NULL_HANDLER, 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,14 +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, @@ -61615,59 +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,12 +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, @@ -61688,15 +71449,19 @@ 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, @@ -61704,45 +71469,59 @@ void zend_vm_init(void) 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,14 +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, @@ -61765,59 +71549,79 @@ 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, ZEND_NULL_HANDLER, 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,14 +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, @@ -63278,63 +73113,83 @@ 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, ZEND_NULL_HANDLER, 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 d1092788d4..cbba373201 100755 --- 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 65342d343b..93e0c6ffeb 100644 --- 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 12d8fa8d67..b821fcbc8f 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -22,7 +22,7 @@ #include <zend.h> #include <zend_vm_opcodes.h> -static const char *zend_vm_opcodes_names[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 922377b72b..c4c9c1c583 100644 --- 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 9c58732e0b..fd70a98ef7 100644 --- 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 e5b390bca6..abdca04334 100644 --- 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 cacda1aef4..1a891a4ebc 100644 --- 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 f40ec15e07..eb56deb558 100644 --- 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 index 0000000000..9c2c5c9137 --- /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 72ae3c3ffe..a25a185e01 100644 --- 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 6b778092f9..595d41e9d4 100644 --- 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 48e9372161..d37a61f83d 100644 --- 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 4b3a0fb306..5be151cb59 100644 --- 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 347f929cbd..4ee14b3ce3 100644 --- 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 305a944cce..d717d46ee2 100644 --- 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 e06ebd5c25..0f5d8cbf21 100644 --- 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 1ddf1a77ca..0528ea08d7 100644 --- 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 cdca12b00e..264c6020ca 100644 --- 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 cc96e04f39..d443999f74 100644 --- 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 f3d5e82309..b33ee41336 100644 --- 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 40c7d2982d..e805da9fa7 100644 --- 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 d8671b9da0..703c1f050a 100644 --- 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, ¤t_row[i]); + ZEND_TRY_ASSIGN_COPY_EX(resultzv, ¤t_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 8a9018356e..a5c1359853 100644 --- 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 2e05afa527..8eda816bd5 100644 --- 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 b7b67562a4..9156347e83 100644 --- 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 9e3a0ab9a1..397458365f 100644 --- 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 89898393a7..95755d559f 100644 --- 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 f88de6202a..a92d773783 100644 --- 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 08e1584923..69a3e81c6b 100644 --- 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 4430f193a8..66dd15da00 100644 --- 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 90107785b7..d5f6c4564b 100644 --- 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 9f1dfdba20..980f3c5fea 100644 --- 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 d13b8a000e..42cd5eef8f 100644 --- 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 ea387bb95f..ad34e7f643 100644 --- 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 index 0000000000..7962b1b893 --- /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 d22cc7ffd7..7b04d0d2df 100644 --- 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 86cb8a2e25..92a77ab792 100644 --- 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 eba9dd23e4..af9244bbf5 100644 --- 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 5fd48a224e..a17d7c4627 100644 --- 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 e97cd8fda6..115801a380 100644 --- 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, ¬ext) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz|b", &zcert, &zout, ¬ext) == 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, ¬ext) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS(), "rz|b", &zcsr, &zout, ¬ext) == 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 b243b22027..cf53edc7f6 100644 --- 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 16ebedd7ac..8622ea8c65 100644 --- 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 0b6fc90253..9355d3d3df 100644 --- 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 105a87da8b..323a4d2fa4 100644 --- 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 14e8382e41..fb472681ca 100644 --- 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 index 0000000000..a83900a123 --- /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 index 0000000000..f1f6e53ebd --- /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 index 0000000000..77f95d77ef --- /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 d949e18107..e47a9615ba 100644 --- 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 15618244ff..49f2a8a7e6 100644 --- 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 7ee8ce416a..375d1556ad 100644 --- 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 c661dbd793..4888309d28 100644 --- 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 1f3a4cd4c7..f80075d3d5 100644 --- 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 91dec7c09e..748263984a 100644 --- 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 e6d68fbea6..0688635450 100644 --- 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 33ea028602..8088c0da8a 100644 --- 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 9026cacc79..38949a6080 100644 --- 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 50f81153a5..15005dce0e 100644 --- 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 aa11a01f47..393b41d0e8 100644 --- 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 5b885c554d..bfad4173a7 100644 --- 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 c962ba4824..93b58e9a94 100644 --- 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 6fc7143cd6..32e651d1e4 100644 --- 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 302599f02b..be2b2668f0 100644 --- 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 d32d1499f3..cf9ba12be8 100644 --- 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 943dafaa43..87a17ab7f6 100644 --- 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 612cdf0f88..8347ea7864 100644 --- 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 37cce100ce..6c7544004b 100644 --- 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 442091ad46..8f67b8b3fc 100644 --- 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 26144eb166..3839512ecc 100644 --- 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 index 0000000000..8b697d5ccb --- /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 index 0000000000..a206a4ba41 --- /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 index 0000000000..9475e8a783 --- /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 1a26e0eaa3..bc1233e35d 100644 --- 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 108bafca8b..27ec44f991 100644 --- 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 d07d657719..8dad71450e 100644 --- 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 a00b73ee8a..0f7726f334 100644 --- 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 9868c5e3c4..d5f2a51312 100644 --- 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 ba5c854aee..2710be98c6 100644 --- 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 737a3f84a5..937f7b1b0f 100644 --- 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 31455daab8..8d533b7907 100644 --- 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 5aa17fb669..dbc6c1603e 100644 --- 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 ba3d6780f1..3cd3dceb8a 100644 --- 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 |